copying the entire english docs before translation

-# Get
+![](get.png)
 
 
-Uma biblioteca de navegação completa que permite navegar entre telas, abrir caixas de diálogo, bottomSheets e exibir snackbars de qualquer lugar do seu código, sem precisar usar context.
-## Ponto de partida
+*Languages: [English](README.md), [Brazilian Portuguese](README.pt-br.md).*
 
 
-*Idiomas: [Inglês](README.md), [Português](README.pt-br.md).*
-
-A navegação convencional do Flutter possui muito código clichê desnecessário, requer contexto para navegar entre telas, abrir caixas de diálogo e usar snackbars em seu projeto pode ser algo desgastante.
-Além disso, quando uma rota é enviada por push, todo o MaterialApp pode ser reconstruído causando congelamentos, bem, isso não acontece com o Get.
-Essa biblioteca que mudará a maneira como você trabalha com o Framework e salvará sua vida do código clichê, aumentando sua produtividade e eliminando os erros de reconstrução do seu aplicativo, além de um conjunto de APIs não disponíveis na biblioteca padrão do Flutter.
+[![pub package](https://img.shields.io/pub/v/get.svg?label=get&color=blue)](https://pub.dev/packages/get) 
+![building](https://github.com/jonataslaw/get/workflows/Test,%20build%20and%20deploy/badge.svg)
+[![Gitter](https://badges.gitter.im/flutter_get/community.svg)](https://gitter.im/flutter_get/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+<a href="https://github.com/Solido/awesome-flutter">
+   <img alt="Awesome Flutter" src="https://img.shields.io/badge/Awesome-Flutter-blue.svg?longCache=true&style=flat-square" />
+</a>
 
 
+Get is an extra-light and powerful library for Flutter that will give you superpowers and increase your productivity. Navigate without context, open dialogs, snackbars or bottomsheets from anywhere in your code, Manage states and inject dependencies in an easy and practical way! Get is secure, stable, up-to-date, and offers a huge range of APIs that are not present on default framework.
 
 
 ```dart
 ```dart
-// Navegação padrão do Flutter:
+// Default Flutter navigator
 Navigator.of(context).push(
 Navigator.of(context).push(
         context,
         context,
         MaterialPageRoute(
         MaterialPageRoute(
            builder: (BuildContext context) { 
            builder: (BuildContext context) { 
-            return HomePage();
+            return Home();
           },
           },
         ),
         ),
       );
       );
 
 
-// Como fazer o mesmo com o Get:
+// Get syntax 
 Get.to(Home());
 Get.to(Home());
 ```
 ```
 
 
-##### Se você está na branch master/dev/beta do Flutter, use a versão 1.20.0-dev.
-* Se você usa Modular, adicione ao seu MaterialApp: navigatorKey: Get.addKey(Modular.navigatorKey)
-
-## Como usar?
-
-Adicione esse pacote ao seu arquivo pubspec.yaml:
-
-```
-dependencies:
-  get: ^1.17.3 // ^1.20.1-dev on beta/dev/master
-```
-  
-Importe ele se seu IDE não fizer isso de forma automática:
+## Getting Started
+
+Flutter's conventional navigation has a lot of unnecessary boilerplate, requires context to navigate between screens, open dialogs, and use snackbars on framework is really boring.
+In addition, when a route is pushed, the entire MaterialApp can be rebuilt causing freezes, this does not happen with Get.
+This library that will change the way you work with the Framework and save your life from cliche code, increasing your productivity, and eliminating the rebuild bugs of your application.
+
+
+- **[How to use?](#how-to-use)**
+- **[Navigating without named routes](#Navigating-without-named-routes)**
+- **[SnackBars](#SnackBars)**
+- **[Dialogs](#Dialogs)**
+- **[BottomSheets](#BottomSheets)**
+- **[Simple State Manager](#Simple-State-Manager)**
+- **[Reactive State Manager](#Reactive-State-Manager)**
+- **[Simple Instance Manager](#Simple-Instance-Manager)**
+- **[Navigate with named routes](#Navigate-with-named-routes)**
+- **[Send data to named Routes](#Send-data-to-named-Routes)**
+- **[Dynamic urls links](#Dynamic-urls-links)**
+- **[Middleware](#Middleware)**
+- **[Optional Global Settings](#Optional-Global-Settings)**
+- **[Other Advanced APIs and Manual configurations](#Other-Advanced-APIs-and-Manual-configurations)**
+- **[Nested Navigators](#Nested-Navigators)**
+
+
+#### You can contribute to the project in multiple ways:
+- Helping to translate the readme into other languages.
+- Adding documentation to the readme (not even half of Get's functions have been documented yet).
+- Writing articles/videos about Get (they will be inserted in the Readme, and in the future in our Wiki).
+- Offering PRs for code/tests.
+- Including new functions.
+
+Any contribution is welcome!
+
+## How to use?
+
+<!-- - Flutter Master/Dev/Beta: version 2.0.x-dev 
+- Flutter Stable branch: version 2.0.x
+(look for latest version on pub.dev) -->
+
+Add Get to your pubspec.yaml file 
+<!-- according to the version of Flutter you are using. -->
+ 
+Exchange your MaterialApp for GetMaterialApp and enjoy!
 ```dart
 ```dart
 import 'package:get/get.dart';
 import 'package:get/get.dart';
+GetMaterialApp( // Before: MaterialApp(
+  home: MyHome(),
+)
 ```
 ```
-Adicione GetKey ao seu MaterialApp e aproveite!
-```dart
-MaterialApp(
-    navigatorKey: Get.key,
-    home: MyHome(),
-  )
-```
-### Navegando sem rotas nomeadas
-Para ir para outra tela:
+## Navigating without named routes
+To navigate to a new screen:
 
 
 ```dart
 ```dart
 Get.to(NextScreen());
 Get.to(NextScreen());
 ```
 ```
 
 
-Para voltar para a tela anterior
+To return to previous screen
 
 
 ```dart
 ```dart
 Get.back();
 Get.back();
 ```
 ```
 
 
-Para ir para a próxima tela e tirar a rota atual da stack de navegação (uso comum em SplashScreens, telas de cadastros e qualquer outra tela que você não deseja exibir quando clicar em voltar)
+To go to the next screen and no option to go back to the previous screen (for use in SplashScreens, login screens and etc.)
 
 
 ```dart
 ```dart
 Get.off(NextScreen());
 Get.off(NextScreen());
 ```
 ```
 
 
-Ir para a próxima tela e tirar todas as telas anteriores da stack de  navegação (geralmente usado em carrinhos de compras, provas, enquetes e etc)
+To go to the next screen and cancel all previous routes (useful in shopping carts, polls, and tests)
 
 
 ```dart
 ```dart
 Get.offAll(NextScreen());
 Get.offAll(NextScreen());
 ```
 ```
 
 
-Para navegar para uma rota e receber ou atualizar dados assim que voltar dela:
+To navigate to the next route, and receive or update data as soon as you return from it:
 ```dart
 ```dart
 var data = await Get.to(Payment());
 var data = await Get.to(Payment());
 ```
 ```
-Na próxima tela, envie algum dado para a screen anterior ao voltar (pode ser qualquer coisa, Strings, int, Maps, até instâncias de classes, você pode tudo):
+on other screen, send a data for previous route:
 
 
 ```dart
 ```dart
 Get.back(result: 'sucess');
 Get.back(result: 'sucess');
 ```
 ```
-E você pode usar o dado recebido assim:
+And use it:
 
 
 ex:
 ex:
 ```dart
 ```dart
 if(data == 'sucess') madeAnything();
 if(data == 'sucess') madeAnything();
 ```
 ```
 
 
-Você não quer aprender nossa sintaxe?
-Basta alterar o Navigator (maiúsculo) para navigator (minúsculo) e você terá todas as funções da navegação padrão, sem precisar usar o contexto
-Exemplo:
+Don't you want to learn our syntax?
+Just change the Navigator (uppercase) to navigator (lowercase), and you will have all the functions of the standard navigation, without having to use context
+Example:
 
 
 ```dart
 ```dart
 
 
-// Navegação padrão
+// Default Flutter navigator
 Navigator.of(context).push(
 Navigator.of(context).push(
         context,
         context,
         MaterialPageRoute(
         MaterialPageRoute(
@@ -105,7 +132,7 @@ Navigator.of(context).push(
         ),
         ),
       );
       );
 
 
-// Usando Get com a sintaxe do Flutter
+// Get using Flutter syntax without needing context
 navigator.push(
 navigator.push(
         MaterialPageRoute(
         MaterialPageRoute(
            builder: (_) { 
            builder: (_) { 
@@ -114,7 +141,7 @@ navigator.push(
         ),
         ),
       );
       );
 
 
-// Usando a sintaxe do Get (Muito  melhor, mas você pode discordar disso)
+// Get syntax (It is much better, but you have the right to disagree)
 Get.to(HomePage());
 Get.to(HomePage());
 
 
 
 
@@ -122,12 +149,12 @@ Get.to(HomePage());
 
 
 ### SnackBars
 ### SnackBars
 
 
-Para ter uma simples SnackBar com Flutter, você deve obter o contexto do Scaffold ou usar uma GlobalKey anexada ao seu Scaffold,
+To have a simple SnackBar with Flutter, you must get the context of Scaffold, or you must use a GlobalKey attached to your Scaffold, 
 ```dart
 ```dart
 final snackBar = SnackBar(
 final snackBar = SnackBar(
-      content: Text('Oi!'),
+      content: Text('Hi!'),
       action: SnackBarAction(
       action: SnackBarAction(
-              label: 'Eu sou uma velha e feia snackbar :(',
+              label: 'I am a old and ugly snackbar :(',
               onPressed: (){}
               onPressed: (){}
             ),
             ),
           // Find the Scaffold in the widget tree and use
           // Find the Scaffold in the widget tree and use
@@ -135,13 +162,13 @@ final snackBar = SnackBar(
           Scaffold.of(context).showSnackBar(snackBar);
           Scaffold.of(context).showSnackBar(snackBar);
 ```
 ```
 
 
-Já com o Get:
+With Get:
 
 
 ```dart
 ```dart
-Get.snackbar('Oi', 'Eu sou uma snackbar bonita e moderna');
+Get.snackbar('Hi', 'i am a modern snackbar');
 ```
 ```
 
 
-Com o Get, tudo o que você precisa fazer é chamar o Get.snackbar de qualquer lugar no seu código ou personalizá-lo como quiser!
+With Get, all you have to do is call your Get.snackbar from anywhere in your code or customize it however you want!
 
 
 ```dart
 ```dart
   Get.snackbar(
   Get.snackbar(
@@ -156,12 +183,13 @@ Com o Get, tudo o que você precisa fazer é chamar o Get.snackbar de qualquer l
             );
             );
 
 
 
 
-  ////////// TODOS RECURSOS //////////
+  ////////// ALL FEATURES //////////
   //     Color colorText,
   //     Color colorText,
   //     Duration duration,
   //     Duration duration,
   //     SnackPosition snackPosition,
   //     SnackPosition snackPosition,
   //     Widget titleText,
   //     Widget titleText,
   //     Widget messageText,
   //     Widget messageText,
+  //     bool instantInit,
   //     Widget icon,
   //     Widget icon,
   //     bool shouldIconPulse,
   //     bool shouldIconPulse,
   //     double maxWidth,
   //     double maxWidth,
@@ -191,39 +219,36 @@ Com o Get, tudo o que você precisa fazer é chamar o Get.snackbar de qualquer l
   //     Form userInputForm
   //     Form userInputForm
   ///////////////////////////////////
   ///////////////////////////////////
 ```
 ```
-Após a recusa de um aplicativo na AppleStore por usar a snackbar padrão que não combina nada com as Human Guidelines da Apple, resolvi criar a Get.snackbar, mas se você prefere a snackbar padrão, ou não desenvolve para iOS, você pode usar a API de baixo nível `GetBar().show();` que permite por exemplo, excluir a mensagem (Get.snackbar tem título e mensagem obrigatórios).
+If you prefer the traditional snackbar, or want to customize it from scratch, including adding just one line (Get.snackbar makes use of a mandatory title and message), you can use 
+`Get.rawSnackbar();` which provides the RAW API on which Get.snackbar was built.
 
 
-### Caixas de dialogos
+### Dialogs
 
 
-Para abrir uma caixa de diálogo:
+To open dialog:
 
 
 ```dart
 ```dart
 Get.dialog(YourDialogWidget());
 Get.dialog(YourDialogWidget());
 ```
 ```
 
 
-Para abrir o dialogo padrão do Get:
+To open default dialog:
 
 
 ```dart
 ```dart
  Get.defaultDialog(
  Get.defaultDialog(
-                title: "My Title",
-                content: Text("Hi, it's my dialog"),
-                confirm: FlatButton(
-                  child: Text("Ok"),
-                  onPressed: () => print("OK pressed"),
-                ),
-                cancel: FlatButton(
-                  child: Text("Cancel"),
-                  onPressed: () => Get.back(),
-                ));
+              onConfirm: () => print("Ok"),
+              middleText: "Dialog made in 3 lines of code");
 ```
 ```
+You can also use Get.generalDialog instead of showGeneralDialog.
+
+For all other Flutter dialog widgets, including cupertinos, you can use Get.overlayContext instead of context, and open it anywhere in your code.
+For widgets that don't use Overlay, you can use Get.context.
+These two contexts will work in 99% of cases to replace the context of your UI, except for cases where inheritedWidget is used without a navigation context.
 
 
 ### BottomSheets
 ### BottomSheets
-Get.bottomSheet é como showModalBottomSheet, mas não precisa de context.
+Get.bottomSheet is like showModalBottomSheet, but don't need of context.
 
 
 ```dart
 ```dart
 Get.bottomSheet(
 Get.bottomSheet(
-      builder: (_){
-          return Container(
+     Container(
             child: Wrap(
             child: Wrap(
             children: <Widget>[
             children: <Widget>[
             ListTile(
             ListTile(
@@ -236,137 +261,522 @@ Get.bottomSheet(
             title: Text('Video'),
             title: Text('Video'),
             onTap: () => {},          
             onTap: () => {},          
           ),
           ),
-            ],
-          ),
+         ],
+        ),
        );
        );
       }
       }
     );
     );
 ```
 ```
-### Configurações Globais
-Você pode criar configurações globais para o Get. Basta adicionar Get.config ao seu código antes de enviar qualquer rota. (Se não souber onde colocar, coloque dentro da função main())
+
+## Simple State Manager
+There are currently several state managers for Flutter. However, most of them involve using ChangeNotifier to update widgets and this is a bad and very bad approach to performance of medium or large applications. You can check in the official Flutter documentation that ChangeNotifier should be used with 1 or a maximum of 2 listeners (https://api.flutter.dev/flutter/foundation/ChangeNotifier-class.html), making it practically unusable for any application medium or large. Other state managers are good, but have their nuances. BLoC is very safe and efficient, but it is very complex for beginners, which has kept people from developing with Flutter. MobX is easier than BLoC and reactive, almost perfect, I would say, but you need to use a code generator that for large applications, reduces productivity, you will need to drink a lot of coffees until your code is ready again after a Flutter clean (And this is not MobX's fault, but the codegen which is really slow!). Provider uses InheritedWidget to deliver the same listener, as a way of solving the problem reported above with ChangeNotifier, which implies that any access to its ChangeNotifier class must be within the widget tree because of the context to access o Inherited.
+
+Get isn't better or worse than any other state manager, but that you should analyze these points as well as the points below to choose between using Get in pure form (Vanilla), or using it in conjunction with another state manager. Definitely, Get is not the enemy of any other state manager, because Get is a microframework, not just a state manager, and can be used either alone or in conjunction with them.
+
+Get has a state manager that is extremely light and easy (written in just 95 lines of code), which does not use ChangeNotifier, will meet the need especially for those new to Flutter, and will not cause problems for large applications.
+
+What performance improvements does Get bring?
+
+1- Update only the required widget.
+
+2- Does not use changeNotifier, it is the state manager that uses less memory (close to 0mb for until).
+
+3- Forget StatefulWidget! With Get you will never need it. With the other state managers, you will probably have to use a StatefulWidget to get the instance of your Provider, BLoC, MobX Controller, etc. But have you ever stopped to think that your appBar, your scaffold, and most of the widgets that are in your class are stateless? So why save the state of an entire class, if you can only save the state of the Widget that is stateful? Get solves that, too. Create a Stateless class, make everything stateless. If you need to update a single component, wrap it with GetBuilder, and its state will be maintained.
+
+4- Organize your project for real! Controllers must not be in your UI, place your TextEditController, or any controller you use within your Controller class.
+
+5- Do you need to trigger an event to update a widget as soon as it is rendered? GetBuilder has the property "initState", just like StatefulWidget, and you can call events from your controller, directly from it, no more events being placed in your initState.
+
+6- Do you need to trigger an action like closing streams, timers and etc? GetBuilder also has the dispose property, where you can call events as soon as that widget is destroyed.
+
+7- Use streams only if necessary. You can use your StreamControllers inside your controller normally, and use StreamBuilder also normally, but remember, a stream reasonably consumes memory, reactive programming is beautiful, but you shouldn't abuse it. 30 streams open simultaneously can be worse than changeNotifier (and changeNotifier is very bad).
+
+8- Update widgets without spending ram for that. Get stores only the GetBuilder creator ID, and updates that GetBuilder when necessary. The memory consumption of the get ID storage in memory is very low even for thousands of GetBuilders. When you create a new GetBuilder, you are actually sharing the state of GetBuilder that has a creator ID. A new state is not created for each GetBuilder, which saves A LOT OF ram for large applications. Basically your application will be entirely Stateless, and the few Widgets that will be Stateful (within GetBuilder) will have a single state, and therefore updating one will update them all. The state is just one.
+
+9- Get is omniscient and in most cases it knows exactly the time to take a controller out of memory. You should not worry about when to dispose of a controller, Get knows the best time to do this. Example:
+
+- Class a => Class B (has controller X) => Class C (has controller X)
+
+In class A the controller is not yet in memory, because you have not used it yet (Get is lazyLoad). In class B you used the controller, and it entered memory. In class C you used the same controller as in class B, Get will share the state of controller B with controller C, and the same controller is still in memory. If you close screen C and screen B, Get will automatically take controller X out of memory and free up resources, because Class a is not using the controller. If you navigate to B again, controller X will enter memory again, if instead of going to class C, you return to class A again, Get will take the controller out of memory in the same way. If class C didn't use the controller, and you took class B out of memory, no class would be using controller X and likewise it would be disposed of. The only exception that can mess with Get, is if you remove B from the route unexpectedly, and try to use the controller in C. In this case, the creator ID of the controller that was in B was deleted, and Get was programmed to remove it from memory every controller that has no creator ID. If you intend to do this, add the "autoRemove: false" flag to class B's GetBuilder and use adoptID = true; in class C's GetBuilder.
+
+### Simple state manager usage
 
 
 ```dart
 ```dart
-Get.config(
-      enableLog = true,
-      defaultPopGesture = true,
-      defaultTransition = Transitions.cupertino}
+// Create controller class and extends GetController
+class Controller extends GetController {
+  int counter = 0;
+  void increment() {
+    counter++;
+    update(this); // use update(this) to update counter variable on UI when increment be called
+  }
+}
+// On your Stateless/Stateful class, use GetBuilder to update Text when increment be called 
+GetBuilder<Controller>(
+    init: Controller(), // INIT IT ONLY THE FIRST TIME
+    builder: (_) => Text(
+              '${_.counter}',
+              )),
+//Initialize your controller only the first time. The second time you are using ReBuilder for the same controller, do not use it again. Your controller will be automatically removed from memory as soon as the widget that marked it as 'init' is deployed. You don't have to worry about that, Get will do it automatically, just make sure you don't start the same controller twice.
+```
+**Done!**
+- You have already learned how to manage states with Get.
+
+- Note: You may want a larger organization, and not use the init property. For that, you can create a class and extends Bindings class, and within it mention the controllers that will be created within that route. Controllers will not be created at that time, on the contrary, this is just a statement, so that the first time you use a Controller, Get will know where to look. Get will remain lazyLoad, and will continue to dispose Controllers when they are no longer needed. See the pub.dev example to see how it works.
+
+
+If you navigate many routes and need data that was in your previously used controller, you just need to use GetBuilder Again (with no init):
+
+```dart
+class OtherClasse extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: Center(
+        child: GetBuilder<Controller>(
+          builder: (s) => Text('${s.counter}'),
+        ),
+      ),
+    );
+  }
+
+```
+If you need to use your controller in many other places, and outside of GetBuilder, just create a get in your controller and have it easily. (or use `Get.find<Controller>()`)
+
+```dart
+class Controller extends GetController {
+
+  /// You do not need that. I recommend using it just for ease of syntax.
+  /// with static method: Controller.to.counter();
+  /// with no static method: Get.find<Controller>().counter();
+  /// There is no difference in performance, nor any side effect of using either syntax. Only one does not need the type, and the other the IDE will autocomplete it.
+  static Controller get to => Get.find(); // add this line 
+
+  int counter = 0;
+  void increment() {
+    counter++;
+    update(this); 
+  }
+}
+```
+And then you can access your controller directly, that way:
+```dart
+FloatingActionButton(
+        onPressed:(){
+         Controller.to.increment(), 
+        } // This is incredibly simple!
+        child: Text("${Controller.to.counter}"),
+      ),
+```
+When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.
+
+#### No StatefulWidget:
+Using StatefulWidgets means storing the state of entire screens unnecessarily, even because if you need to minimally rebuild a widget, you will embed it in a Consumer/Observer/BlocProvider/GetBuilder, which will be another StatefulWidget.
+The StatefulWidget class is a class larger than StatelessWidget, which will allocate more RAM, and this may not make a significant difference between one or two classes, but it will most certainly do when you have 100 of them!
+Unless you need to use a mixin, like TickerProviderStateMixin, it will be totally unnecessary to use a StatefulWidget with Get. 
+
+You can call all methods of a StatefulWidget directly from a GetBuilder.
+If you need to call initState() or dispose() method for example, you can call them directly;
+
+```dart
+GetBuilder<Controller>(
+          initState(_) => Controller.to.fetchApi(),
+          dispose(_) => Controller.to.closeStreams(),
+          builder: (s) => Text('${s.username}'),
+        ),
+```
+
+A much better approach than this is to use the onInit() and onClose() method directly from your controller.
+
+```dart
+@override
+void onInit() {
+  fetchApi();
+  super.onInit();
+}
 ```
 ```
 
 
-## Gerenciador de instâncias descomplicado
-Além de aumentar produtividade, muita gente usa Get para ter um aplicativo menor. Se você tem várias rotas e snackbars em seu aplicativo, ele provavelmente terá um código final maior que seu aplicativo + essa biblioteca
-Se você já está usando o Get e deseja tornar seu projeto o mais enxuto possível, agora o Get possui um gerenciador de instancias simples que permite recuperar a mesma classe do seu Bloc ou Controller com apenas 1 linhas de código.
+- NOTE: If you want to start a method at the moment the controller is called for the first time, you DON'T NEED to use constructors for this, in fact, using a performance-oriented package like Get, this borders on bad practice, because it deviates from the logic in which the controllers are created or allocated (if you create an instance of this controller, the constructor will be called immediately, you will be populating a controller before it is even used, you are allocating memory without it being in use, this definitely hurts the principles of this library). The onInit() methods; and onClose(); were created for this, they will be called when the Controller is created, or used for the first time, depending on whether you are using Get.lazyPut or not. If you want, for example, to make a call to your API to populate data, you can forget about the old-fashioned method of initState/dispose, just start your call to the api in onInit, and if you need to execute any command like closing streams, use the onClose() for that.
+The purpose of this package is precisely to give you a complete solution for navigation of routes, management of dependencies and states, using the least possible dependencies, with a high degree of decoupling. Get engages all high and low level Flutter APIs within itself, to ensure that you work with the least possible coupling. We centralize everything in a single package, to ensure that you don't have any kind of coupling in your project. That way, you can put only widgets in your view, and leave the part of your team that works with the business logic free, to work with the business logic without depending on any element of the View. This provides a much cleaner working environment, so that part of your team works only with widgets, without worrying about sending data to your controller, and part of your team works only with the business logic in its breadth, without depending on no element of the view.
+
+So to simplify this:
+You don't need to call methods in initState and send them by parameter to your controller, nor use your controller constructor for that, you have the onInit() method that is called at the right time for you to start your services.
+You do not need to call the device, you have the onClose() method that will be called at the exact moment when your controller is no longer needed and will be removed from memory. That way, leave views for widgets only, refrain from any kind of business logic from it.
+
+Do not call a dispose method inside GetController, it will not do anything, remember that the controller is not a Widget, you should not "dispose" it, and it will be automatically and intelligently removed from memory by Get. If you used any stream on it and want to close it, just insert it into the close method. Example:
 
 
 ```dart
 ```dart
-Controller controller = Get.put(Controller()); // Em vez de Controller controller = Controller();
+class Controller extends GetController {
+StreamController<User> user = StreamController<User>();
+StreamController<String> name = StreamController<String>();
+
+/// close stream = onClose method, not dispose.
+@override
+void onClose() {
+  user.close();
+  name.close();
+  super.onClose();
+}
+
 ```
 ```
-Em vez de instanciar seu controlador dentro da classe que você está usando, use o metodo put para que o Get pegue sua instância e disponibilize por todo o seu aplicativo.
-Então você pode usar seu controlador (ou classe Bloc) normalmente.
+Controller life cycle:
+- onInit() where it is created.
+- onClose() where it is closed to make any changes in preparation for the delete method
+- deleted: you do not have access to this API because it is literally removing the controller from memory. It is literally deleted, without leaving any trace.
+
+##### Forms of use:
+
+- Recommended usage:
+
+You can use Controller instance directly on GetBuilder value:
+
+```dart
+GetBuilder<Controller>(  
+    init: Controller(),
+    builder: (value) => Text(
+              '${value.counter}', //here
+              )),
+```
+You may also need an instance of your controller outside of your GetBuilder, and you can use these approaches to achieve this:
+
+```dart
+class Controller extends GetController {
+  static Controller get to => Get.find(); 
+[...]
+}
+// on stateful/stateless class
+GetBuilder<Controller>(  
+    init: Controller(), // use it only first time on each controller
+    builder: (_) => Text(
+              '${Controller.to.counter}', //here
+              )),
+or 
+
+class Controller extends GetController {
+ // static Controller get to => Get.find(); // with no static get
+[...]
+}
+// on stateful/stateless class
+GetBuilder<Controller>(  
+    init: Controller(), // use it only first time on each controller
+    builder: (_) => Text(
+              '${Get.find<Controller>().counter}', //here
+              )),
+```
+
+- You can use "non-canonical" approaches to do this. If you are using some other dependency manager, like get_it, modular, etc., and just want to deliver the controller instance, you can do this:
+
+```dart
+
+Controller controller = Controller();
+[...]
+GetBuilder( // you dont need to type on this way
+    init: controller, //here
+    builder: (_) => Text(
+              '${controller.counter}', // here
+              )),
+
+```
+This approach is not recommended, as you will have to manually dispose of your controllers, close your streams manually, and literally give up one of the great benefits of this library, which is intelligent memory control. But if you trust your potential, go ahead!
+
+If you want to refine a widget's update control with GetBuilder, you can assign them unique IDs:
+```dart
+GetBuilder<Controller>( 
+    id: 'text' 
+    init: Controller(), // use it only first time on each controller
+    builder: (_) => Text(
+              '${Get.find<Controller>().counter}', //here
+              )),
+```
+And update it this form:
+```dart
+update(this,['text']);
+```
+You can also impose conditions for the update:
+
+```dart
+update(this,['text'], counter < 10);
+```
+
+GetX does this automatically and only reconstructs the widget that uses the exact variable that was changed, if you change a variable to the same as the previous one and that does not imply a change of state , GetX will not rebuild the widget to save memory and CPU cycles (3 is being displayed on the screen, and you change the variable to 3 again. In most state managers, this will cause a new rebuild, but with GetX the widget will only is rebuilt again, if in fact his state has changed).
+GetBuilder is aimed precisely at multiple state control. Imagine that you added 30 products to a cart, you click delete one, at the same time that the list is updated, the price is updated and the badge in the shopping cart is updated to a smaller number. This type of approach makes GetBuilder killer, because it groups states and changes them all at once without any "computational logic" for that. GetBuilder was created with this type of situation in mind, since for ephemeral change of state, you can use setState and you would not need a state manager for this. However, there are situations where you want only the widget where a certain variable has been changed to be rebuilt, and this is what GetX does with a mastery never seen before.
+
+That way, if you want an individual controller, you can assign IDs for that, or use GetX. This is up to you, remembering that the more "individual" widgets you have, the more the performance of GetX will stand out, while the performance of GetBuilder should be superior, when there is multiple change of state.
+
+You can use both in any situation, but if you want to tune their application to the maximum possible performance, I would say that: if your variables are changed at different times, use GetX, because there is no competition for it when the subject is to rebuild only what is necessary, if you do not need unique IDs, because all your variables will be changed when you perform an action, use GetBuilder, because it is a simple state updater in blocks, made in a few lines of code, to make just what he promises to do: update state in blocks. There is no way to compare RAM, CPU, or anything else from a giant state manager to a simple StatefulWidget (like GetBuilder) that is updated when you call update(this). It was done in a simple way, to have the least computational logic involved, just to fulfill a single purpose and spend the minimum resources possible for that purpose.
+If you want a powerful state manager, you can go without fear to GetX. It does not work with variables, but flows, everything in it is streams under the hood. You can use rxDart in conjunction with it, because everything is stream, you can hear the event of each "variable", because everything in it is stream, it is literally BLoC, easier than MobX, and without code generator or decorations .
+
+
+## Reactive State Manager
+
+If you want power, Get gives you the most advanced state manager you could ever have.
+GetX was built 100% based on Streams, and give you all the firepower that BLoC gave you, with an easier facility than using MobX.
+Without decorations, you can turn anything into Observable with just a ".obs".
+
+Maximum performance: In addition to having a smart algorithm for minimal reconstruction, Get uses comparators to make sure the state has changed. If you experience any errors in your application, and send a duplicate change of state, Get will ensure that your application does not collapse.
+The state only changes if the values ​​change. That's the main difference between Get, and using Computed from MobX. When joining two observables, when one is changed, the hearing of that observable will change. With Get, if you join two variables (which is unnecessary computed for that), GetX (similar to Observer) will only change if it implies a real change of state. Example:
+
+```dart
+final count1 = 0.obs;
+final count2 = 0.obs;
+int get sum => count1.value + count2.value;
+```
+
+```dart
+ GetX<Controller>(
+              builder: (_) {
+                print("count 1 rebuild");
+                return Text('${_.count1.value}');
+              },
+            ),
+            GetX<Controller>(
+              builder: (_) {
+                print("count 2 rebuild");
+                return Text('${_.count2.value}');
+              },
+            ),
+            GetX<Controller>(
+              builder: (_) {
+                print("count 3 rebuild");
+                return Text('${_.sum}');
+              },
+            ),
+```
+
+If we increment the number of count 1, only count 1 and count 3 are reconstructed, because count 1 now has a value of 1, and 1 + 0 = 1, changing the sum value.
+
+If we change count 2, only count2 and 3 are reconstructed, because the value of 2 has changed, and the result of the sum is now 2.
+
+If we add the number 1 to count 1, which already contains 1, no widget is reconstructed. If we add a value of 1 for count 1 and a value of 2 for count 2, only 2 and 3 will be reconstructed, simply because GetX not only changes what is necessary, it avoids duplicating events.
+
+In addition, Get provides refined state control. You can condition an event (such as adding an object to a list), on a certain condition.
+
+```dart
+list.addIf(item<limit, item);
+```
+
+Without decorations, without a code generator, without complications, GetX will change the way you manage your states in Flutter, and that is not a promise, it is a certainty!
+
+Do you know Flutter's counter app? Your Controller class might look like this:
+
+```dart
+class CountCtl extends RxController {
+  final count = 0.obs;
+}
+```
+With a simple:
+```dart
+ctl.count.value++
+```
+
+You could update the counter variable in your UI, regardless of where it is stored.
+
+You can transform anything on obs:
+
+```dart
+class RxUser {
+  final name = "Camila".obs;
+  final age = 18.obs;
+}
+
+class User {
+  User({String name, int age});
+  final rx = RxUser();
+
+  String get name => rx.name.value;
+  set name(String value) => rx.name.value = value;
+
+  int get age => rx.age.value;
+  set age(int value) => rx.age.value = value;
+}
+```
+
+```dart
+
+void main() {
+  final user = User();
+  print(user.name);
+  user.age = 23;
+  user.rx.age.listen((int age) => print(age));
+  user.age = 24;
+  user.age = 25;
+}
+___________
+out:
+Camila
+23
+24
+25
+
+```
+
+Before you immerse yourself in this world, I will give you a tip, always access the "value" of your flow when reading it, especially if you are working with lists where this is apparently optional.
+You can access list.length, or list.value.length. Most of the time, both ways will work, since the GetX list inherits directly from the dart List. But there is a difference between you accessing the object, and accessing the flow. I strongly recommend you to access the value:
+```dart
+final list = List<User>().obs;
+```
+```dart
+ListView.builder (
+itemCount: list.value.lenght
+```
+or else create a "get" method for it and abandon "value" for life. example:
+
+```dart
+final _list = List<User>().obs;
+List get list => _list.value;
+```
+```dart
+ListView.builder (
+itemCount: list.lenght
+```
+You could add an existing list of another type to the observable list using a list.assign (oldList); or the assignAll method, which differs from add, and addAll, which must be of the same type. All existing methods in a list are also available on GetX.
+
+We could remove the obligation to use value with a simple decoration and code generator, but the purpose of this lib is precisely not to need any external dependency. It is to offer an environment ready for programming, involving the essentials (management of routes, dependencies and states), in a simple, light and performance way without needing any external package. You can literally add 3 letters to your pubspec (get) and start programming. All solutions included by default, from route management to state management, aim at ease, productivity and performance. The total weight of this library is less than that of a single state manager, even though it is a complete solution, and that is what you must understand. If you are bothered by value, and like a code generator, MobX is a great alternative, and you can use it in conjunction with Get. For those who want to add a single dependency in pubspec and start programming without worrying about the version of a package being incompatible with another, or if the error of a state update is coming from the state manager or dependency, or still, do not want to worrying about the availability of controllers, whether literally "just programming", get is just perfect.
+If you have no problem with the MobX code generator, or have no problem with the BLoC boilerplate, you can simply use Get for routes, and forget that it has state manager. Get SEM and RSM were born out of necessity, my company had a project with more than 90 controllers, and the code generator simply took more than 30 minutes to complete its tasks after a Flutter Clean on a reasonably good machine, if your project it has 5, 10, 15 controllers, any state manager will supply you well. If you have an absurdly large project, and code generator is a problem for you, you have been awarded this solution.
+
+Obviously, if someone wants to contribute to the project and create a code generator, or something similar, I will link in this readme as an alternative, my need is not the need for all devs, but for now I say, there are good solutions that already do that, like MobX.
+
+## Simple Instance Manager
+Are you already using Get and want to make your project as lean as possible? Get has a simple and powerful dependency manager that allows you to retrieve the same class as your Bloc or Controller with just 1 lines of code, no Provider context, no inheritedWidget:
+
+```dart
+Controller controller = Get.put(Controller()); // Rather Controller controller = Controller();
+```
+Instead of instantiating your class within the class you are using, you are instantiating it within the Get instance, which will make it available throughout your App.
+So you can use your controller (or class Bloc) normally
 
 
 ```dart
 ```dart
 controller.fetchApi();// Rather Controller controller = Controller();
 controller.fetchApi();// Rather Controller controller = Controller();
 ```
 ```
 
 
-Agora, imagine que você navegou por inúmeras rotas e precisa de dados que foram deixados para trás em seu controlador; você precisaria de um gerenciador de estado combinado com o Provider ou Get_it, correto? Não com Get. Você só precisa pedir ao Get para "procurar" pelo seu controlador, você não precisa de nenhuma dependência adicional para isso:
+Imagine that you have navigated through numerous routes, and you need a data that was left behind in your controller, you would need a state manager combined with the Provider or Get_it, correct? Not with Get. You just need to ask Get to "find" for your controller, you don't need any additional dependencies:
 
 
 ```dart
 ```dart
 Controller controller = Get.find();
 Controller controller = Get.find();
-// Sim, parece Magia, o Get irá descobrir qual é seu controller, e irá te entregar. Você pode ter 1 milhão de controllers instanciados, o Get sempre te entregará o controller correto. Apenas se lembre de Tipar seu controller, final controller = Get.find(); por exemplo, não irá funcionar.
+//Yes, it looks like Magic, Get will find your controller, and will deliver it to you. You can have 1 million controllers instantiated, Get will always give you the right controller.
 ```
 ```
-E então você poderá recuperar os dados do seu controlador obtidos lá:
+And then you will be able to recover your controller data that was obtained back there:
 
 
 ```dart
 ```dart
 Text(controller.textFromApi);
 Text(controller.textFromApi);
 ```
 ```
 
 
-Quer liberar recursos? Para remover uma instância do Get, apenas delete ela:
+Looking for lazy loading? You can declare all your controllers, and it will be called only when someone needs it. You can do this with:
+```dart
+Get.lazyPut<Service>(()=> ApiMock());
+/// ApiMock will only be called when someone uses Get.find<Service> for the first time
+```
 
 
+To remove a instance of Get:
 ```dart
 ```dart
-Controller controller = Get.delete(Controller());
+Get.delete<Controller>();
 ```
 ```
-Pronto, você consegue fazer mais com menos código, diminuiu o tamanho de código do seu app, e agora tem um gerenciador de instâncias ultra leve, com apenas 1 biblioteca.
 
 
-## Navegando com rotas nomeadas:
-- Se você prefere navegar por rotas nomeadas, o Get também dá suporte a isso. 
 
 
-Para navegar para uma nova tela
+## Navigate with named routes:
+- If you prefer to navigate by namedRoutes, Get also supports this.
+
+To navigate to nextScreen
 ```dart
 ```dart
 Get.toNamed("/NextScreen");
 Get.toNamed("/NextScreen");
 ```
 ```
-Para navegar para uma tela sem a opção de voltar para a rota atual.
+To navigate and remove the previous screen from the tree.
 ```dart
 ```dart
 Get.offNamed("/NextScreen");
 Get.offNamed("/NextScreen");
 ```
 ```
-Para navegar para uma nova tela e remover todas rotas anteriores da stack
+To navigate and remove all previous screens from the tree.
 ```dart
 ```dart
 Get.offAllNamed("/NextScreen");
 Get.offAllNamed("/NextScreen");
 ```
 ```
 
 
-### Enviando dados por rotas nomeadas:
+To define routes, use GetMaterialApp:
+
+```dart
+void main() {
+  runApp(GetMaterialApp(
+    initialRoute: '/',
+    namedRoutes: {
+      '/': GetRoute(page: MyHomePage()),
+      '/second': GetRoute(page: Second()),
+      '/third': GetRoute(page: Third(),transition: Transition.cupertino);
+    },
+  ));
+}
+```
+
+### Send data to named Routes:
 
 
-Apenas envie o que você quiser por argumentos. Get aceita qualquer coisa aqui, não importa se é uma String, um Map, uma List, int ou até uma instancia de classe.
+Just send what you want for arguments. Get accepts anything here, whether it is a String, a Map, a List, or even a class instance.
 ```dart
 ```dart
 Get.toNamed("/NextScreen", arguments: 'Get is the best');
 Get.toNamed("/NextScreen", arguments: 'Get is the best');
 ```
 ```
-Agora você pode recuperar em sua classe ou em seu controller:
+on your class or controller:
 
 
 ```dart
 ```dart
 print(Get.arguments);
 print(Get.arguments);
 //print out: Get is the best
 //print out: Get is the best
 ```
 ```
 
 
-## Configurando rotas nomeadas e adicionando suporte completo à urls amigáveis do Flutter Web
+#### Dynamic urls links
+Get offer advanced dynamic urls just like on the Web. Web developers have probably already wanted this feature on Flutter, and most likely have seen a package promise this feature and deliver a totally different syntax than a URL would have on web, but Get also solves that.
 
 
-### Se você ainda não adicionou " navigatorKey: Get.key," ao seu MaterialApp, faça agora. aproveite para adicionar uma  "initialRoute" e o seu "onGenerateRoute".
+```dart
+Get.offAllNamed("/NextScreen?device=phone&id=354&name=Enzo");
+```
+on your controller/bloc/stateful/stateless class:
+
+```dart
+print(Get.parameters['id']);
+// out: 354
+print(Get.parameters['name']);
+// out: Enzo
+```
+
+You can also receive NamedParameters with Get easily:
 
 
 ```dart
 ```dart
 void main() {
 void main() {
-  runApp(MaterialApp(
-    onGenerateRoute: Router.generateRoute,
-    initialRoute: "/",
-    navigatorKey: Get.key,
-    title: 'Navigation',
+  runApp(GetMaterialApp(
+    initialRoute: '/',
+    namedRoutes: {
+      '/': GetRoute(page: MyHomePage()),
+      /// Important!  :user is not a new route, it is just a parameter
+      /// specification. Do not use '/second/:user' and '/second'
+      /// if you need new route to user, use '/second/user/:user' 
+      /// if '/second' is a route.
+      '/second/:user': GetRoute(page: Second()), // receive ID
+      '/third': GetRoute(page: Third(),transition: Transition.cupertino);
+    },
   ));
   ));
 }
 }
 ```
 ```
-Crie uma classe para gerenciar suas rotas nomeadas, você pode (e deve) copiar esse exemplo
-
-```dart
-class Router {
-  static Route<dynamic> generateRoute(RouteSettings settings) {
-    switch (settings.name) {
-      case '/':
-        return GetRoute(
-          page: First(),
-          settings: settings,
-        );
-      case '/second':
-        return GetRoute(
-            settings: settings, page: Second(), transition: Transition.fade);
-      case '/third':
-        return GetRoute(
-            settings: settings,
-            page: Third(),
-            popGesture: true,
-            transition: Transition.cupertino);
-      default:
-        return GetRoute(
-            settings: settings,
-            transition: Transition.fade,
-            page: Scaffold(
-              body:
-                  Center(child: Text('No route defined for ${settings.name}')),
-            ));
-    }
-  }
-}
+Send data on route name
+```dart
+Get.toNamed("/second/34954");
+```
+
+On second screen take the data by parameter
+
+```dart
+print(Get.parameters['user']);
+// out: 34954
 ```
 ```
 
 
-E agora, tudo que você precisa fazer é usar Get.toNamed() para navegar pelas rotas nomeadas, sem qualquer context (você pode chamar suas rotas diretamente da sua classe BLoC ou Controller) e, quando o aplicativo for compilado na Web, suas rotas aparecerão na URL <3
+And now, all you need to do is use Get.toNamed() to navigate your named routes, without any context (you can call your routes directly from your BLoC or Controller class), and when your app is compiled to the web, your routes will appear in the url <3
+
 
 
 #### Middleware 
 #### Middleware 
-Se você deseja ouvir eventos de navegação para acionar ações, é possível adicionar um GetObserver ao seu materialApp. Isso é extremamente útil para acionar eventos sempre que uma tela específica é exibida na tela. Atualmente no Flutter, você teria que colocar o evento no initState e aguardar uma possível resposta em um navigator.pop (context); para conseguir isso. Mas com o Get, isso é extremamente simples!
+If you want listen Get events to trigger actions, you can to use routingCallback to it
+```dart
+GetMaterialApp(
+  routingCallback: (route){
+    if(routing.current == '/second'){
+      openAds();
+    }
+  }
+  ```
+If you are not using GetMaterialApp, you can use the manual API to attach Middleware observer.
+
 
 
-##### add GetObserver();
 ```dart
 ```dart
 void main() {
 void main() {
   runApp(MaterialApp(
   runApp(MaterialApp(
@@ -384,9 +794,9 @@ Create a MiddleWare class
 ```dart
 ```dart
 class MiddleWare {
 class MiddleWare {
   static observer(Routing routing) {
   static observer(Routing routing) {
-    /// Você pode ouvir além das rotas, snackbars, caixas de diálogo e bottomsheets em cada tela.
-   /// Se você precisar inserir qualquer um desses 3 eventos diretamente aqui,
-   /// você deve especificar que o evento é != Do que você está tentando fazer ou você terá um loop.
+    /// You can listen in addition to the routes, the snackbars, dialogs and bottomsheets on each screen. 
+    ///If you need to enter any of these 3 events directly here, 
+    ///you must specify that the event is != Than you are trying to do.
     if (routing.current == '/second' && !routing.isSnackbar) {
     if (routing.current == '/second' && !routing.isSnackbar) {
       Get.snackbar("Hi", "You are on second route");
       Get.snackbar("Hi", "You are on second route");
     } else if (routing.current =='/third'){
     } else if (routing.current =='/third'){
@@ -395,7 +805,8 @@ class MiddleWare {
   }
   }
 }
 }
 ```
 ```
-Agora é só usar o Get em seu código:
+
+Now, use Get on your code:
 
 
 ```dart
 ```dart
 class First extends StatelessWidget {
 class First extends StatelessWidget {
@@ -468,68 +879,120 @@ class Third extends StatelessWidget {
 }
 }
 ```
 ```
 
 
+### Change Theme
+Please do not use any higher level widget than GetMaterialApp in order to update it. This can trigger duplicate keys. A lot of people are used to the prehistoric approach of creating a "ThemeProvider" widget just to change the theme of your app, and this is definitely NOT necessary with Get.
+
+You can create your custom theme and simply add it within Get.changeTheme without any boilerplate for that:
+
+
+```dart
+Get.changeTheme(ThemeData.light());
+```
+
+If you want to create something like a button that changes the theme with onTap, you can combine two Get APIs for that, the api that checks if the dark theme is being used, and the theme change API, you can just put this within an onPressed:
+
+```dart
+Get.changeTheme(Get.isDarkMode? ThemeData.light(): ThemeData.dark());
+```
+
+When darkmode is activated, it will switch to the light theme, and when the light theme is activated, it will change to dark.
+
+
+If you want to know in depth how to change the theme, you can follow this tutorial on Medium that even teaches the persistence of the theme using Get:
+
+- [Dynamic Themes in 3 lines using Get](https://medium.com/swlh/flutter-dynamic-themes-in-3-lines-c3b375f292e3) - Tutorial by [Rod Brown](https://github.com/RodBr).
+
+
+### Optional Global Settings
+You can create Global settings for Get. Just add Get.config to your code before pushing any route or do it directly in your GetMaterialApp
+
+```dart
+
+GetMaterialApp(    
+    enableLog: true,
+    defaultTransition: Transition.fade,
+    opaqueRoute: Get.isOpaqueRouteDefault,
+    popGesture: Get.isPopGestureEnable,
+    transitionDuration: Get.defaultDurationTransition,
+    defaultGlobalState: Get.defaultGlobalState,
+    );
 
 
-### APIs Avançadas
-A cada dia, o Get fica mais longe do Framework padrão e fornece uma gama mais ampla de recursos que são impensáveis de serem executados usando o Flutter padrão.
-Com o Get 1.17.0, foi lançada uma série de novas APIs, que permitem por exemplo, o acesso dos argumentos de uma rota nomeada de qualquer lugar do código, se há alguma snackbar ou caixa de diálogo aberta naquele momento ou qual tela está sendo exibida para o usuário.
-Este é um grande passo para desanexar completamente a navegação Flutter de InheritedWidgets. Usar o contexto para acessar o InheritedWidget para usar um recurso simples de navegação é uma das únicas coisas chatas que se pode encontrar nessa estrutura incrível que é o Flutter. Agora, o Get resolveu esse problema, tornou-se onisciente e você terá acesso a basicamente qualquer ferramenta do Flutter que está disponível apenas na árvore de widgets usando o Get.
+Get.config(
+      enableLog = true,
+      defaultPopGesture = true,
+      defaultTransition = Transitions.cupertino}
+```
 
 
-Todas as APIs disponíveis aqui estão na fase beta; elas são totalmente funcionais, passaram em testes internos, mas como foram recém lançadas, não tem maturidade suficiente para garantir sua estabilidade. Get é totalmente estável (quase sempre issues abertas são solicitações de recursos, quase nunca bugs), mas esse conjunto de APIs foi lançado recentemente, portanto, se você encontrar algum erro aqui, abra um problema ou ofereça um PR.
 
 
-- Obrigatório: para ter acesso a essa API, você deve obrigatoriamente inserir o GetObserver em seu MaterialApp 
+### Other Advanced APIs and Manual configurations
+GetMaterialApp configures everything for you, but if you want to configure Get Manually using advanced APIs.
 
 
 ```dart
 ```dart
 MaterialApp(
 MaterialApp(
       navigatorKey: Get.key,
       navigatorKey: Get.key,
-      navigatorObservers: [GetObserver()], // COLOQUE AQUI !!!!
+      navigatorObservers: [GetObserver()],
     );
     );
 ```
 ```
 
 
-Você também poderá usar seu próprio Middleware no GetObserver, isso não influenciará em nada.
+You will also be able to use your own Middleware within GetObserver, this will not influence anything.
 
 
 ```dart
 ```dart
 MaterialApp(
 MaterialApp(
       navigatorKey: Get.key,
       navigatorKey: Get.key,
-      navigatorObservers: [GetObserver(MiddleWare.observer)], // AQUI
+      navigatorObservers: [GetObserver(MiddleWare.observer)], // Here
     );
     );
 ```
 ```
 
 
-Principais APIs:
-
 ```dart
 ```dart
-Get.arguments // Te dá os argumentos da rota aberta em qualquer lugar do seu código. 
-              // você não precisa mais recebê-los, inicializa-los no seu initState e enviar por parâmetro ao seu controller/Bloc, Get é onisciente, ele sabe exatamente qual rota está aberta e quais argumentos enviados para ela. Você pode usar isso diretamente no seu controller/bloc sem medo.
+Get.arguments // give the current args from currentScreen
+
+Get.previousArguments // give arguments of previous route
+
+Get.previousRoute // give name of previous route
+
+Get.rawRoute // give the raw route to access for example, rawRoute.isFirst()
+
+Get.routing // give access to Rounting API from GetObserver
+
+Get.isSnackbarOpen // check if snackbar is open
+
+Get.isDialogOpen // check if dialog is open
 
 
-Get.previousArguments // Te dá os argumentos da rota anterior. 
+Get.isBottomSheetOpen // check if bottomsheet is open
 
 
-Get.previousRoute // Te dá o nome da rota anterior
+Get.removeRoute() // remove one route.
 
 
-Get.rawRoute // te dá acesso à rota crua, para explorar APIs de baixo nível
+Get.until() // back repeatedly until the predicate returns true.
 
 
-Get.routing // te dá acesso à Rounting API do GetObserver
+Get.offUntil() // go to next route and remove all the previous routes until the predicate returns true.
 
 
-Get.isSnackbarOpen // verifique se a snackbar está sendo exibida na tela
+Get.offNamedUntil() // go to next named route and remove all the previous routes until the predicate returns true.
 
 
-Get.isDialogOpen // verifique se a caixa de diálogo está sendo exibida na tela
+GetPlatform.isAndroid/isIOS/isWeb... //(This method is completely compatible with FlutterWeb, unlike the framework. "Platform.isAndroid")
 
 
-Get.isBottomSheetOpen // verifique se a bottomsheet está sendo exibida na tela
+Get.height / Get.width // Equivalent to the method: MediaQuery.of(context).size.height
 
 
+Get.context // Gives the context of the screen in the foreground anywhere in your code.
+
+Get.contextOverlay // Gives the context of the snackbar/dialog/bottomsheet in the foreground anywhere in your code.
 
 
 ```
 ```
+
 ### Nested Navigators
 ### Nested Navigators
 
 
-Get fez a navegação aninhada do Flutter ainda mais fácil.
-Você não precisa do contexto e encontrará sua pilha de navegação por um ID exclusivo.
+Get made Flutter's nested navigation even easier.
+You don't need the context, and you will find your navigation stack by Id.
 
 
-Veja como é simples:
+- NOTE: Creating parallel navigation stacks can be dangerous. The ideal is not to use NestedNavigators, or to use sparingly. If your project requires it, go ahead, but keep in mind that keeping multiple navigation stacks in memory may not be a good idea for RAM consumption.
 
 
+See how simple it is:
 ```dart
 ```dart
              Navigator(
              Navigator(
-                key: nestedKey(1), // crie sua key por um index
+                key: nestedKey(1), // create a key by index
                 initialRoute: '/',
                 initialRoute: '/',
                 onGenerateRoute: (settings) {
                 onGenerateRoute: (settings) {
                   if (settings.name == '/') {
                   if (settings.name == '/') {
-                    return GetRoute(
+                    return GetRouteBase(
                       page: Scaffold(
                       page: Scaffold(
                         appBar: AppBar(
                         appBar: AppBar(
                           title: Text("Main"),
                           title: Text("Main"),
@@ -538,14 +1001,14 @@ Veja como é simples:
                           child: FlatButton(
                           child: FlatButton(
                               color: Colors.blue,
                               color: Colors.blue,
                               onPressed: () {
                               onPressed: () {
-                                Get.toNamed('/second', 1); // navegue por sua rota aninhada usando o index
+                                Get.toNamed('/second', id:1); // navigate by your nested route by index
                               },
                               },
                               child: Text("Go to second")),
                               child: Text("Go to second")),
                         ),
                         ),
                       ),
                       ),
                     );
                     );
                   } else if (settings.name == '/second') {
                   } else if (settings.name == '/second') {
-                    return GetRoute(
+                    return GetRouteBase(
                       page: Center(
                       page: Center(
                         child: Scaffold(
                         child: Scaffold(
                           appBar: AppBar(
                           appBar: AppBar(
@@ -562,27 +1025,4 @@ Veja como é simples:
 ```
 ```
 
 
 
 
-### Outras APIs:
-Desde quando essa biblioteca foi criada, reuni meus esforços para adicionar novos recursos e torná-la mais estável possível. Com isso, ainda há algumas APIs disponíveis que ainda não foram documentadas. Meu tempo é escasso, então vou resumir as principais aqui:
-
-```dart
-Get.removeRoute() // remove uma rota
-
-Get.until() // volta repetidamente até o predicado ser verdadeiro
-
-Get.offUntil() // vá para a próxima rota e remova todas as rotas anteriores até que o predicado retornar verdadeiro.
-
-Get.offNamedUntil() // vá para a próxima rota nomeada e remova todas as rotas anteriores até que o predicado retorne verdadeiro (namedRoutes)
-
-GetPlatform.isAndroid/isIOS/isWeb... //(Este método é totalmente compatível com o FlutterWeb, diferente do padrão "Platform.isAndroid" que usa dart:io)
-
-Get.height / Get.width // Equivalente ao método: MediaQuery.of(context).size.height //width
-
-Get.context // Fornece o contexto da tela em primeiro plano em qualquer lugar do seu código.
-
-Get.overlayContext // Fornece o contexto do dialogo/snackbar/bottomsheet em primeiro plano em qualquer lugar do seu código.
-
-
-```
-
-Essa biblioteca será sempre atualizada e implementando novos recursos. Sinta-se livre para oferecer PRs e contribuir com ela.
+This library will always be updated and implementing new features. Feel free to offer PRs and contribute to them.