Recent Trend

A Non-Euclidean Rendering Engine for 3D scenes.
Rudimentary Roam replica with Org-mode

1000+ Hand-Crafted Go Examples, Exercises, and Quizzes
Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.
jExcel is a lightweight vanilla javascript plugin to create amazing web-based interactive tables and spreadsheets compatible with Excel or any other spreadsheet software.
? A collection of pure bash alternatives to external processes.
Google Research
Course Files for Complete Python 3 Bootcamp Course on Udemy
A book series on JavaScript. @YDKJS on twitter.
Backstage is an open platform for building developer portals
Simple and minimalistic server dashboard
A super-easy, composable, web server framework for warp speeds.
Midway is a Node.js Serverless Framework for front-end/full-stack developers. Build the application for next decade. Works on AWS, Aliyun, Tencent-Cloud and traditional VM/Container.
Ready-to-use OCR with 40+ languages supported including Chinese, Japanese, Korean and Thai
A curated list of awesome Discord communities for programmers
Build cross-platform desktop apps with JavaScript, HTML, and CSS
A database software completely built as JSON files in backend. A powerful, portable and simple database works on top of JSON files. It is like a database software, currently having basic CRUD operatio
Simple and minimalistic server dashboard
App to show cast info for breaking bad

python powered Intelligent System
Repository for tutorial sessions at EEML2020
? A collection of Firebase plugins for Flutter apps.
Firefox Preview
基于Gin + Vue + Element UI的前后端分离权限管理系统脚手架(包含了:基础用户管理功能,jwt鉴权,代码生成器,RBAC资源控制,表单构建等)文档: Demo:
Vite & Vue powered static site generator
Zulip server - powerful open source team chat
If Google News had a Python library
Revive unavailable songs for Netease Cloud Music
YApi 是一个可本地部署的、打通前后端及QA的、可视化的接口管理平台
The plugin-driven server agent for collecting & reporting metrics.
All materials for the Cassandra Workshop Series in a single place
A beautiful Redis GUI ?
Collection of Summer 2021 tech internships!
Cubit is a lightweight state management solution. It is a subset of the bloc package that does not rely on events and instead uses methods to emit new states.
Native-ESM powered web dev build tool. It's fast.
An Electron boilerplate including TypeScript, React, Jest and ESLint.
A modified browser that helps in responsive web development.
Build Mobile, Desktop and WebAssembly apps with C# and XAML. Today. Open source and professionally supported.
React components for faster and easier web development. Build your own design system, or start with Material Design.
Welcome to the Bot Framework samples repository. Here you will find task-focused samples in C#, JavaScript and TypeScript to help you get started with the Bot Framework SDK!
OpenPCDet Toolbox for LiDAR-based 3D Object Detection.
A simplified Jira clone built with Angular 9 and Akita
The ultimate snippets collection for VS Code
Based on a true story
Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies.

? React Hooks for forms validation (Web + React Native)
Node Version Manager - POSIX-compliant bash script to manage multiple active node.js versions
开放式跨端跨框架解决方案,支持使用 React/Vue/Nerv 等框架来开发微信/京东/百度/支付宝/字节跳动/ QQ 小程序/H5 等应用。
A GUI frontend for @werman's Pulse Audio real-time noise suppression plugin
Updates to this repository will continue to arrive until the number of links reaches 10000 links & 10000 pdf files .Learn Ethical Hacking and penetration testing .hundreds of ethical hacking & penetra
Blazing fast hexapod robot simulator with React and Plotly.
C++ game engine focusing on modern rendering techniques and performance.
Silice is an open source language that simplifies writing algorithms fully exploiting FPGA architectures.
Python training for business analysts and traders
Official tensorflow implementation for CVPR2020 paper “Learning to Cartoonize Using White-box Cartoon Representations”
Ultimate Go study guide
This is a fun, new monospaced font that includes programming ligatures and is designed to enhance the modern look and feel of the Windows Terminal.
Rolling Rhino; convert Ubuntu into a rolling release as seen on YouTube
A repo for the pre-course work at home exercises
Learn python3 in one picture.
? TensorflowTTS: Real-Time State-of-the-art Speech Synthesis for Tensorflow 2
Drench yourself in Deep Learning, Reinforcement Learning, Machine Learning, Computer Vision, and NLP by learning from these exciting lectures!!
Matplotlib styles for scientific plotting
A pendant to warn you when you touch your face
A collection of all my Flutter Challenges
To-do list & time tracker for programmers & other digital workers with Jira, Github and Gitlab integration
Instant messaging server; backend in Go; iOS, Android, web, command line clients; chatbots
Graph Neural Networks with Keras and Tensorflow 2.
The near-instant build tool for modern web apps.
Books for machine learning, deep learning, math, NLP, CV, RL, etc
? List of awesome university courses for learning Computer Science!
Distributed scheduled job framework
? 互联网 Java 工程师进阶知识完全扫盲:涵盖高并发、分布式、高可用、微服务、海量数据处理等领域知识,后端同学必看,前端同学也可学习
PlayStation 2 DVD Player Exploit
Store SSH keys in the Secure Enclave
Learning Convolutional Neural Networks with Interactive Visualization.
阿里巴巴 MySQL binlog 增量订阅&消费组件
Open Source Computer Vision Library
Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin.
LeetCode Solutions: A Record of My Problem Solving Journey.( leetcode题解,记录自己的leetcode解题之路。)
? Building a federated alternative to reddit in rust
egui: Immediate mode GUI written in Rust, made for WASM
Open screens/snackbars/dialogs/bottomSheets without context, manage states and inject dependencies easily with Get.
beego is an open-source, high-performance web framework for the Go programming language.
A lightweight and ultra-fast tool for building observability pipelines
BBT - Bug Bounty Tools
Example code for HTML, CSS, and Javascript for Web Developers Coursera Course
? HonKit is building beautiful books using Markdown - Fork of GitBook
Display and control your Android device
Build forms in React, without the tears ?
A sandbox tower defense game
ARCore Depth Lab is a set of Depth API samples that provides assets using depth for advanced geometry-aware features in AR interaction and rendering. (UIST 2020)
Virtual-machine Translation Intermediate Language
Free online textbook of Jupyter notebooks for Computational Linear Algebra course
PyTorch implementation of FastSurferCNN
Solar2D Game Engine main repository (ex Corona SDK)
《On Java 8》中文版,又名《Java编程思想》 第5版
A collection of all the data i could extract from 1 billion leaked credentials from internet.
Minimal distributed configuration management in bash
California COVID Assessment Tool
CLI tool for Angular
? fgprof is a sampling Go profiler that allows you to analyze On-CPU as well as Off-CPU (e.g. I/O) time together.
Terraform AWS provider
Finally, a "back to top" button that behaves like a real elevator.
A toolkit for developing high-performance HTTP reverse proxy applications.
One framework. Mobile & desktop.
Data science Python notebooks: Deep learning (TensorFlow, Theano, Caffe, Keras), scikit-learn, Kaggle, big data (Spark, Hadoop MapReduce, HDFS), matplotlib, pandas, NumPy, SciPy, Python essentials, AW
Learn the skills required to sysadmin a remote Linux server from the commandline.
A Patch for GIMP 2.10+ for Photoshop Users
Distributed SQL database in Rust, written as a learning project
A cheat sheet that contains common enumeration and attack methods for Windows Active Directory.
Fluent System Icons is a set of mobile platform icons from Microsoft
The PHP Interpreter
A list of Free Software network services and web applications which can be hosted locally. Selfhosting is the process of hosting and managing applications instead of renting from Software-as-a-Service
? Open source machine learning framework to automate text- and voice-based conversations: NLU, dialogue management, connect to Slack, Facebook, and more - Create chatbots and voice assistants
Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more
A curated awesome list of lists of interview questions. Feel free to contribute! ?
Windows system utilities to maximize productivity
Build a ReactJS App workshop
This cheasheet is aimed at the CTF Players and Beginners to help them understand the fundamentals of Privilege Escalation with examples.
Highly cited and useful papers related to machine learning, deep learning, AI, game theory, reinforcement learning
The Ruby Programming Language [mirror]
? The missing package manager for macOS (or Linux)
[CVPR2020] Adversarial Latent Autoencoders
? A UI Design Language and React UI library
High performance Spigot fork that aims to fix gameplay and mechanics inconsistencies
Learn OpenCV : C++ and Python Examples
A utility-first CSS framework for rapid UI development.
An extremely fast JavaScript bundler and minifier
⚛️ Hooks for fetching, caching and updating asynchronous data in React
[CVPR 2020] 3D Photography using Context-aware Layered Depth Inpainting
Nginx UI allows you to access and modify the nginx configurations files without cli.
《史上最简单的Spring Cloud教程源码》
Learning operating system development using Linux kernel and Raspberry Pi
A traffic simulation game exploring how small changes to roads affect cyclists, transit users, pedestrians, and drivers.
Apache Spark - A unified analytics engine for large-scale data processing
Open-source IoT Platform - Device management, data collection, processing and visualization.
For better displaying html files and course material use this link
▶️ 跨平台桌面端视频资源播放器.简洁无广告.免费高颜值. ?
Modern HTTP benchmarking tool
傲娇钉宫,鞭写鞭骂 - 钉宫理惠 vscode-rainbow-fart 扩展语音包
Resources for Blazor, a .NET web framework using C#/Razor and HTML that runs in the browser with WebAssembly.
Smart NFC & ink-Display Card
Read all about it on GrumpyGamer:

A very minimal but elegant emacs (I think)

TeachYourselfCS 的中文翻译 | A Chinese translation of TeachYourselfCS
Tsunami is a general purpose network security scanner with an extensible plugin system for detecting high severity vulnerabilities with high confidence.

spring boot demo 是一个用来深度学习并实战 spring boot 的项目,目前总共包含 65 个集成demo,已经完成 53 个。 该项目已成功集成 actuator(监控)、admin(可视化监控)、logback(日志)、aopLog(通过AOP记录web请求日志)、统一异常处理(json级别和页面级别)、freemarker(模板引擎)、thymeleaf(模板引擎)、Be
Code Sample of Book "Effective Python: 59 Specific Ways to Write Better Pyton" by Brett Slatkin
VK driver for the Raspberry Pi (Broadcom Videocore IV)
Face Depixelizer based on "PULSE: Self-Supervised Photo Upsampling via Latent Space Exploration of Generative Models" repository.
告别枯燥,60 秒学会一个 Python 小例子
AI and Machine Learning with Kubeflow, Amazon EKS, and SageMaker
DeDRM tools for ebooks
A complete computer science study plan to become a software engineer.
Novel Coronavirus (COVID-19) Cases, provided by JHU CSSE
Original Apollo 11 Guidance Computer (AGC) source code for the command and lunar modules.
Empowering everyone to build reliable and efficient software.
Command-line program to download videos from and other video sites
Arduino core for the ESP32

An open source re-implementation of Diablo 2
Extremely fast non-cryptographic hash algorithm
A collective list of free APIs for use in software and web development.
This is a repo which documents real bugs in real software to illustrate trends, learn how to prevent or find them more quickly.
Kubernetes Goat is "Vulnerable by Design" Kubernetes Cluster.
Curated list of project-based tutorials
一个在你编程时疯狂称赞你的 VSCode 扩展插件 | An VSCode extension that keeps giving you compliment while you are coding, it will checks the keywords of code to play suitable sounds.

Combination of multiple linters to install as a GitHub Action
Open Source / i18n / Cross Platform Contact Tracing App by exposure notification framework.

A list of GOG Galaxy 2.0 integrations and upcoming features
InputStream based Netflix plugin for Kodi
GoPlus - The Go+ language for data science
Pokémon Save File Editor
Detectron2 is FAIR's next-generation platform for object detection and segmentation.
The Central Kubernetes Management Platform For Any Infrastructure
End-to-End Encryption for Zoom Meetings



一个涵盖六个专栏:Spring Boot 2.X、Spring Cloud、Spring Cloud Alibaba、Dubbo、分布式消息队列、分布式事务的仓库。希望胖友小手一抖,右上角来个 Star,感恩 1024
A beautiful, fully open-source, tunneling service - written in pure PHP
NOTE: Please report here only issues related to the python API. Issues and general feedback regarding the Galaxy Client 2.0 shall be sent via Galaxy Client menu
一套涵盖大部分核心组件使用的Spring Cloud教程,包括Spring Cloud Alibaba及分布式事务Seata,基于Spring Cloud Greenwich及SpringBoot 2.1.7。20篇文章,篇篇精华,30个Demo,涵盖大部分应用场景。

Self-Supervised Learning Toolbox and Benchmark
A scriptable scratchpad for developers. In slow yet steady progress.
PARL A high-performance distributed training framework for Reinforcement Learning
React Hooks Library
Open source documentation of Microsoft Azure
Lens - The Kubernetes IDE

The AWS Cloud Development Kit is a framework for defining cloud infrastructure in code
multi_task_NLP is a utility toolkit enabling NLP developers to easily train and infer a single model for multiple tasks.
Python - 100天从新手到大师
A tool for refactoring code related to feature flag APIs
Davinci is a DVsaaS (Data Visualization as a Service) Platform
StyleGAN2 - Official TensorFlow Implementation
[mirror] Home of the website
BYOB (Build Your Own Botnet)
Native iOS app using the exposure notification framework from Apple.

Corona-Warn-App website
Documentation for the Microsoft Graph REST API
The source for REST API specifications for Microsoft Azure.

Elegant HTTP Networking in Swift
Declarative continuous deployment for Kubernetes.
Date & Time pickers, built with ❤️ for @material-ui/core
An open source, portable, easy to use, readable and flexible SSL library
A library for generating fake data such as names, addresses, and phone numbers.
A simple baseline for one-shot multi-object tracking
700+ Pure CSS, SVG & Figma UI Icons Available in SVG Sprite, styled-components, NPM & API
Arm Mbed OS is a platform operating system designed for the internet of things
Testcontainers is a Java library that supports JUnit tests, providing lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container.
Core integrations of the Datadog Agent
Backend implementation of the verification process
A tool for secrets management, encryption as a service, and privileged access management
The files from the United States government on 9/11, released by wiki leaks.
PULSE: Self-Supervised Photo Upsampling via Latent Space Exploration of Generative Models
JSON for Modern C++
High-Resolution 3D Human Digitization from A Single Image.
Android terminal and Linux environment - packages repository.
Tools to set up a quick macOS VM in QEMU, accelerated by KVM.

An ebook reader application supporting PDF, DjVu, EPUB, FB2 and many more formats, running on Cervantes, Kindle, Kobo, PocketBook and Android devices
Social network for developers, built on the MERN stack
Install Linux from a running Windows system, without need for a live USB.
Backend implementation for the Apple/Google exposure notification API.
OpenCore bootloader
GPT-3: Language Models are Few-Shot Learners
Native Android app using the Apple/Google exposure notification API.
An advanced Twitter scraping & OSINT tool written in Python that doesn't use Twitter's API, allowing you to scrape a user's followers, following, Tweets and more while evading most API limitations.


ESP8266 core for Arduino
Flash OS images to SD cards & USB drives, safely and easily.
⏬ Dumb downloader that scrapes the web
An enterprise-class UI components based on Ant Design and Vue.
The fastai deep learning library, plus lessons and tutorials
Collection of 8000+ publicly available IPTV channels from all over the world
The ultimate collection of scripts for YouTube-DL.
A secure JavaScript and TypeScript runtime
nodejsscan is a static security code scanner for Node.js applications.
Lean's OpenWrt source
Source code for the book "Violent Python" by TJ O'Connor. The code has been fully converted to Python 3, reformatted to comply with PEP8 standards and refactored to eliminate issues involving the impl
A delightful networking framework for iOS, macOS, watchOS, and tvOS.
Microsoft Quantum Development Kit Samples

Open source audio annotation tool for humans™
Source code for the book "Black Hat Python" by Justin Seitz. The code has been fully converted to Python 3, reformatted to comply with PEP8 standards and refactored to eliminate issues of dependency r
A long list of (advanced) JavaScript questions, and their explanations ✨
Code for a dynamic multilevel Bayesian model to predict US presidential elections. Written in R and Stan.
A modular framework for vision & language multimodal research from Facebook AI Research (FAIR)
A payment application to demonstrate real-world usage of Cypress testing methods, patterns, and workflows.

Build machine learning APIs
Haskell-style functional programming language running on Erlang VM.

PowerShell script for automation of routine tasks done after fresh installations of Windows 10 / Server 2016 / Server 2019
Node library to automate Chromium, Firefox and WebKit with a single API
程序员如何优雅的挣零花钱,2.0版,升级为小书了。Most of this not work outside China , so no English translate
A library that provides an embeddable, persistent key-value store for fast storage.
CVE-2020-0796 Remote Code Execution POC is an open source base building game inspired by factorio! Available on web & desktop
Eclipse Theia is a cloud & desktop IDE framework implemented in TypeScript.
CVPR 2020 论文开源项目合集
mall项目是一套电商系统,包括前台商城系统及后台管理系统,基于SpringBoot+MyBatis实现,采用Docker容器化部署。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
Xamarin.Forms Official Home
Atari 8 bit computers, NES and SMS game consoles on your TV with nothing more than a ESP32 and a sense of nostalgia
手把手撕LeetCode题目,扒各种算法套路的裤子。English version supported! Crack LeetCode, not only how, but also why.
Hide secrets with invisible characters in plain text securely using passwords
Open-source self-hosted email marketing. Manage your own newsletters at a fraction of the cost.

This repository holds the content submitted to Files added to the tutorials/ will appear at
"More than just a rewrite of Windows Explorer"
Gravity Programming Language
A full-stack framework for Laravel that takes the pain out of building dynamic UIs.

Full ASP.NET Core 3.1 application with DDD, CQRS and Event Sourcing concepts
Hummingbird compiles trained ML models into tensor computation for faster inference.
Procedurally generated Chinese landscape painting.
Vulnerability checker for Callstranger (CVE-2020-12695)
UtahFS is an encrypted storage system that provides a user-friendly FUSE drive backed by cloud storage.

Bringing Characters to Life with Computer Brains in Unity
YOLOv5 in PyTorch > ONNX > CoreML > iOS
Fast, easy and reliable testing for anything that runs in a browser.

Googletest - Google Testing and Mocking Framework
Google Cloud Client Libraries for Go.
Stay Awake is a simple app that keeps your computer from going to sleep.
The fastest wiki and knowledge base for growing teams. Beautiful, feature rich, and markdown compatible.
PHP Static Analysis Tool - discover bugs in your code without running it!
Docker images for .NET Core and the .NET Core Tools.
CryptoSwift is a growing collection of standard and secure cryptographic algorithms implemented in Swift

The ultimate Free Open Source Solution for team communications.
A uniform interface to run deep learning models from multiple frameworks
n³ The missing terminal file manager for X.
The Docker toolset to pack, ship, store, and deliver content
Seamless REST/GraphQL API mocking library for browser and Node.
ShowDoc is a tool greatly applicable for an IT team to share documents online一个非常适合IT团队的在线API文档、技术文档工具
Device code for the Meshtastic ski/hike/fly/customizable open GPS radio

A Ruby static code analyzer and formatter, based on the community Ruby style guide.
A Collection of application ideas which can be used to improve your coding skills.
fsociety Hacking Tools Pack – A Penetration Testing Framework
Documentation for ASP.NET Core
binary releases of VS Code without MS branding/telemetry/licensing
The Incredible PyTorch: a curated list of tutorials, papers, projects, communities and more relating to PyTorch.
Firebase iOS SDK
A guide to writing a DNS Server from scratch in Rust
A dynamic infrastructure toolkit for red teamers and bug bounty hunters!
Super-project for modularized Boost
Bootstrap post-collapse technology
A new type of shell
A series of Jupyter notebooks that walk you through the fundamentals of Machine Learning and Deep Learning in Python using Scikit-Learn, Keras and TensorFlow 2.
A very simple toon lit shader example, for you to learn writing custom lit shader in Unity URP
How I'm learning to build secure systems
SpringBoot 相关漏洞学习资料,利用方法和技巧合集,黑盒安全评估 checklist
A curated list of insanely awesome libraries, packages and resources for Quants (Quantitative Finance)
A Markdown Editor for the 21st century.
My Python Examples
Azure RTOS ThreadX is an advanced real-time operating system (RTOS) designed specifically for deeply embedded applications.
Open Source real-time strategy game engine for early Westwood games such as Command & Conquer: Red Alert written in C# using SDL and OpenGL. Runs on Windows, Linux, *BSD and Mac OS X.
Python Data Science Handbook: full text in Jupyter Notebooks
Deepfakes Software For All
tic-tac-toe in a single call to printf
Notebooks based on financial machine learning.
Nomad is an easy-to-use, flexible, and performant workload orchestrator that can deploy a mix of microservice, batch, containerized, and non-containerized applications. Nomad is easy to operate and sc
All Algorithms implemented in Python
simplest possible native GUI for inspecting JSON objects with jq
Create beautiful diagrams just by typing mathematical notation in plain text.
TensorFlow Tutorial and Examples for Beginners (support TF v1 & v2)
JetBrains license servers 2020-2021 IntelliJ WebStorm PyCharm PhpStorm 05 May 2020 works; yo ho ho from Ukraine!
All Algorithms implemented in C++
Avatars for Zoom, Skype and other video-conferencing apps.
All Algorithms implemented in Java
Advanced table plugin
Repository containing evidence of police brutality during the 2020 George Floyd protests

Lightning Fast, Ultra Relevant, and Typo-Tolerant Search Engine
Reset your IDE eval information.
Mac in Docker! Run near native OSX-KVM in Docker! X11 Forwarding!

A place for creators and users of password managers to collaborate on resources to make password management better.
A genetic algorithm toy project for drawing
An unidentifiable mechanism that helps you bypass GFW.
Python tool for grabbing text via screenshot
vue-admin-beautiful是一款绝佳的前端开发框架(基于vue/cli 4 最新版,同时支持电脑,手机,平板),长期更新维护,感谢您的star,我一直在努力 Vue admin beautiful is an excellent front-end development framework (supporting computers, mobile phones and tablet
An interactive deep learning book with code, math, and discussions.
A platform for building proxies to bypass network restrictions.
Reset Intellij IDEA, WebStorm, DataGrip, PhpStorm, CLion, PyCharm, RubyMine, GoLand and Rider evaluation (2019 / 2020 / Mac OS)
深度学习入门开源书,基于TensorFlow 2.0案例实战。Open source Deep Learning book, based on TensorFlow 2.0 framework.
The iconic SVG, font, and CSS toolkit
Run macOS on QEMU/KVM. With OpenCore Now! No free support is provided. Open PR(s) to fix problems.
Project overview, general documentation, and white papers.


Productive & portable programming language for high-performance, sparse & differentiable computing
DeepFaceLab is the leading software for creating deepfakes.
Personal Wiki for Vim
✅ The Node.js best practices list (June 2020)
A fast JSON parser/generator for Java.
Substrate: The platform for blockchain innovators
Web APIs for Django.
Collection of Technical Interview Questions solved with Go
End-to-End Object Detection with Transformers
Flutter仿微博客户端, 包含首页、视频、发现、消息(仿微博聊界面)及个人中心模块
Practical Python Programming (course by @dabeaz)


Open screens/snackbars/dialogs/bottomSheets without context, manage states and inject dependencies easily with Get.

Languages: English (this file), Brazilian Portuguese, Spanish.

pub package building Gitter

Awesome Flutter

Buy Me A Coffee

GetX makes your development productive, but want to make it even more productive? Add the extension GetX extension to VSCode to your VSCode

The "counter" project created by default on new project on Flutter has over 100 lines (with comments). To show the power of Get, I will demonstrate how to make a "counter" changing the state with each click, switching between pages and sharing the state between screens, all in an organized way, separating the business logic from the view, in ONLY 26 LINES CODE INCLUDING COMMENTS.

class Controller extends GetxController{
  var count = 0.obs; 
  increment() => count.value++;

class Other extends StatelessWidget { // You can ask Get to find a Controller that is being used by another page and redirect you to it. final Controller c = Get.find();

@override Widget build(context){ // Access the updated count variable return Scaffold(body: Center(child: Text(c.count.string))); }

This is a simple project but it already makes clear how powerful Get is. As your project grows, this difference will become more significant. Get was designed to work with teams, but it makes the job of an individual developer simple. Improve your deadlines, deliver everything on time without losing performance. Get is not for everyone, but if you identified with that phrase, Get is for you!

- [Route Management](#route-management)
  - [How to use?](#how-to-use)
  - [Navigation without named routes](#navigation-without-named-routes)
  - [Navigation with named routes](#navigation-with-named-routes)
    - [Send data to named Routes:](#send-data-to-named-routes)
    - [Dynamic urls links](#dynamic-urls-links)
    - [Middleware](#middleware)
  - [Navigation without context](#navigation-without-context)
    - [SnackBars](#snackbars)
    - [Dialogs](#dialogs)
    - [BottomSheets](#bottomsheets)
  - [Nested Navigation](#nested-navigation)
- [State Management](#state-management)
  - [Simple State Manager](#simple-state-manager)
    - [Advantages](#advantages)
    - [Usage](#usage)
    - [How it handles controllers](#how-it-handles-controllers)
    - [You won't need StatefulWidgets anymore](#you-wont-need-statefulwidgets-anymore)
    - [Why it exists](#why-it-exists)
    - [Other ways of using it](#other-ways-of-using-it)
    - [Unique IDs](#unique-ids)
  - [Reactive State Manager](#reactive-state-manager)
    - [Advantages](#advantages-1)
    - [Usage](#usage-1)
    - [Where .obs can be used](#where-obs-can-be-used)
    - [Note about Lists](#note-about-lists)
    - [Why i have to use .value?](#why-i-have-to-use-value)
    - [Obx()](#obx)
    - [Workers:](#workers)
  - [Mixing the two state managers](#mixing-the-two-state-managers)
  - [GetBuilder vs GetX && Obx vs MixinBuilder](#getbuilder-vs-getx-vs-obx-vs-mixinbuilder)
- [Dependency Management](#dependency-management)
  - [Simple Instance Manager](#simple-instance-manager)
  - [Bindings](#bindings)
    - [How to use](#how-to-use-1)
  - [SmartManagement](#smartmanagement)
- [Utils](#utils)
  - [Change Theme](#change-theme)
  - [Other Advanced APIs and Manual configurations](#other-advanced-apis-and-manual-configurations)
    - [Optional Global Settings](#optional-global-settings)
- [Breaking changes from 2.0](#breaking-changes-from-2.0)

*Want to contribute to the project? We will be proud to highlight you as one of our collaborators. Here are some points where you can contribute and make Get (and Flutter) even better.*

- Helping to translate the readme into other languages.
- Adding documentation to the readme (not even half of Get's functions have been documented yet).
- Write articles or make videos teaching how to use Get (they will be inserted in the Readme and in the future in our Wiki).
- Offering PRs for code/tests.
- Including new functions.

# Route Management

Any contribution is welcome!

## How to use?

Add this to your pubspec.yaml file:

dependencies: get:

If you are going to use routes/snackbars/dialogs/bottomsheets without context, or use the high-level Get APIs, you need to simply add "Get" before your MaterialApp, turning it into GetMaterialApp and enjoy!

GetMaterialApp( // Before: MaterialApp(
  home: MyHome(),

Navigation without named routes

To navigate to a new screen:;

To close snackbars, dialogs, bottomsheets, or anything you would normally close with Navigator.pop(context);


To go to the next screen and no option to go back to the previous screen (for use in SplashScreens, login screens and etc.);

To go to the next screen and cancel all previous routes (useful in shopping carts, polls, and tests)


To navigate to the next route, and receive or update data as soon as you return from it:

var data = await;

on other screen, send a data for previous route:

Get.back(result: 'success');

And use it:


if(data == 'success') madeAnything();

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:

// Default Flutter navigator
    builder: (BuildContext context) { 
      return HomePage();

// Get using Flutter syntax without needing context
    builder: (_) { 
      return HomePage();

// Get syntax (It is much better, but you have the right to disagree);

Navigation with named routes

To navigate to nextScreen


To navigate and remove the previous screen from the tree.


To navigate and remove all previous screens from the tree.


To define routes, use GetMaterialApp:

void main() {
      initialRoute: '/',
      getPages: [
        GetPage(name: '/', page: () => MyHomePage()),
        GetPage(name: '/second', page: () => Second()),
          name: '/third',
          page: () => Third(),
          transition: Transition.zoom  

Send data to named Routes:

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.

Get.toNamed("/NextScreen", arguments: 'Get is the best');

on your class or controller:

//print out: Get is the best

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.


on your controller/bloc/stateful/stateless class:

// out: 354
// out: Enzo

You can also receive NamedParameters with Get easily:

void main() {
      initialRoute: '/',
      getPages: [
        name: '/',
        page: () => MyHomePage(),
        name: '/profile/',
        page: () => MyProfile(),
       //You can define a different page for routes with arguments, and another without arguments, but for that you must use the slash '/' on the route that will not receive arguments as above.
        name: '/profile/:user',
        page: () => UserProfile(),
        name: '/third',
        page: () => Third(),
        transition: Transition.cupertino  

Send data on route name


On second screen take the data by parameter

// out: 34954

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


If you want listen Get events to trigger actions, you can to use routingCallback to it

  routingCallback: (routing) {
    if(routing.current == '/second'){

If you are not using GetMaterialApp, you can use the manual API to attach Middleware observer.

void main() {
      onGenerateRoute: Router.generateRoute,
      initialRoute: "/",
      navigatorKey: Get.key,
      navigatorObservers: [
        GetObserver(, // HERE !!!

Create a MiddleWare class

class MiddleWare {
  static observer(Routing routing) {
    /// 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) {
      Get.snackbar("Hi", "You are on second route");
    } else if (routing.current =='/third'){
      print('last route called');

Now, use Get on your code:

class First extends StatelessWidget {
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        leading: IconButton(
          icon: Icon(Icons.add),
          onPressed: () {
            Get.snackbar("hi", "i am a modern snackbar");
        title: Text('First Route'),
      body: Center(
        child: RaisedButton(
          child: Text('Open route'),
          onPressed: () {

class Second extends StatelessWidget {
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        leading: IconButton(
          icon: Icon(Icons.add),
          onPressed: () {
            Get.snackbar("hi", "i am a modern snackbar");
        title: Text('second Route'),
      body: Center(
        child: RaisedButton(
          child: Text('Open route'),
          onPressed: () {

class Third extends StatelessWidget {
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Third Route"),
      body: Center(
        child: RaisedButton(
          onPressed: () {
          child: Text('Go back!'),

Navigation without context


To have a simple SnackBar with Flutter, you must get the context of Scaffold, or you must use a GlobalKey attached to your Scaffold

final snackBar = SnackBar(
  content: Text('Hi!'),
  action: SnackBarAction(
    label: 'I am a old and ugly snackbar :(',
    onPressed: (){}
// Find the Scaffold in the widget tree and use
// it to show a SnackBar.

With Get:

Get.snackbar('Hi', 'i am a modern snackbar');

With Get, all you have to do is call your Get.snackbar from anywhere in your code or customize it however you want!

  "Hey i'm a Get SnackBar!", // title
  "It's unbelievable! I'm using SnackBar without context, without boilerplate, without Scaffold, it is something truly amazing!", // message
  icon: Icon(Icons.alarm), 
  shouldIconPulse: true,
  barBlur: 20,
  isDismissible: true,
  duration: Duration(seconds: 3),

  ////////// ALL FEATURES //////////
  //     Color colorText,
  //     Duration duration,
  //     SnackPosition snackPosition,
  //     Widget titleText,
  //     Widget messageText,
  //     bool instantInit,
  //     Widget icon,
  //     bool shouldIconPulse,
  //     double maxWidth,
  //     EdgeInsets margin,
  //     EdgeInsets padding,
  //     double borderRadius,
  //     Color borderColor,
  //     double borderWidth,
  //     Color backgroundColor,
  //     Color leftBarIndicatorColor,
  //     List<BoxShadow> boxShadows,
  //     Gradient backgroundGradient,
  //     FlatButton mainButton,
  //     OnTap onTap,
  //     bool isDismissible,
  //     bool showProgressIndicator,
  //     AnimationController progressIndicatorController,
  //     Color progressIndicatorBackgroundColor,
  //     Animation<Color> progressIndicatorValueColor,
  //     SnackStyle snackStyle,
  //     Curve forwardAnimationCurve,
  //     Curve reverseAnimationCurve,
  //     Duration animationDuration,
  //     double barBlur,
  //     double overlayBlur,
  //     Color overlayColor,
  //     Form userInputForm

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.


To open dialog:


To open default dialog:

  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.


Get.bottomSheet is like showModalBottomSheet, but don't need of context.

    child: Wrap(
      children: <Widget>[
          leading: Icon(Icons.music_note),
          title: Text('Music'),
          onTap: () => {}
          leading: Icon(Icons.videocam),
          title: Text('Video'),
          onTap: () => {},

Nested Navigation

Get made Flutter's nested navigation even easier. You don't need the context, and you will find your navigation stack by Id.

See how simple it is:

  key: Get.nestedKey(1), // create a key by index
  initialRoute: '/',
  onGenerateRoute: (settings) {
    if ( == '/') {
      return GetPageRoute(
        page: Scaffold(
          appBar: AppBar(
            title: Text("Main"),
          body: Center(
            child: FlatButton(
              onPressed: () {
                Get.toNamed('/second', id:1); // navigate by your nested route by index
              child: Text("Go to second"),
    } else if ( == '/second') {
      return GetPageRoute(
        page: Center(
          child: Scaffold(
            appBar: AppBar(
              title: Text("Main"),
            body: Center(
              child:  Text("second")

State Management

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, making it practically unusable for any application medium or large.

Other state managers are good, but have their nuances:

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.

Simple State Manager

Get has a state manager that is extremely light and easy, which does not use ChangeNotifier, will meet the need especially for those new to Flutter, and will not cause problems for large applications.


  1. Update only the required widgets.

  2. Does not use changeNotifier, it is the state manager that uses less memory (close to 0mb).

  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.


// Create controller class and extends GetxController
class Controller extends GetxController {
  int counter = 0;
  void increment() {
    update(); // use update() to update counter variable on UI when increment be called
// On your Stateless/Stateful class, use GetBuilder to update Text when increment be called 
  init: Controller(), // INIT IT ONLY THE FIRST TIME
  builder: (_) => Text(
//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.


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):

class OtherClass extends StatelessWidget {
  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>())

class Controller extends GetxController {

  /// You do not need that. I recommend using it just for ease of syntax.
  /// with static method:;
  /// 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() {

And then you can access your controller directly, that way:

  onPressed: () {, 
  } // This is incredibly simple!
  child: Text("${}"),

When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.

How it handles controllers

Let's say we have this:

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.

You won't need StatefulWidgets anymore

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/GetX/Obx, 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;

  initState: (_) =>,
  dispose: (_) =>,
  builder: (s) => Text('${s.username}'),

A much better approach than this is to use the onInit() and onClose() method directly from your controller.

void onInit() {

Why it exists

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 GetxController, 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:

class Controller extends GetxController {
  StreamController<User> user = StreamController<User>();
  StreamController<String> name = StreamController<String>();

  /// close stream = onClose method, not dispose.
  void onClose() {

Controller life cycle:

Other ways of using it

You can use Controller instance directly on GetBuilder value:

  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:

class Controller extends GetxController {
  static Controller get to => Get.find(); 
// on you view:
  init: Controller(), // use it only first time on each controller
  builder: (_) => Text(
    '${}', //here


class Controller extends GetxController {
 // static Controller get to => Get.find(); // with no static get
// on stateful/stateless class
  init: Controller(), // use it only first time on each controller
  builder: (_) => Text(
    '${Get.find<Controller>().counter}', //here
Controller controller = Controller();
  init: controller, //here
  builder: (_) => Text(
    '${controller.counter}', // here

Unique IDs

If you want to refine a widget's update control with GetBuilder, you can assign them unique IDs:

  id: 'text' 
  init: Controller(), // use it only first time on each controller
  builder: (_) => Text(
    '${Get.find<Controller>().counter}', //here

And update it this form:


You can also impose conditions for the update:

update(['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).

Reactive State Manager

Reactive programming can alienate many people because it is said to be complicated. Getx turns reactive programming into something so simple, that it can be used and learned by those who started at that very moment in Flutter. No, you will not need to create StreamControllers. You also won't need to create a StreamBuilder for each variable. You will not need to create a class for each state. You will not need to create a get for an initial value. Reactive programming with Get is as easy as using setState (or even easier!).

Let's imagine that you have a name variable and want that every time you change it, all widgets that use it are automatically changed.

This is your count variable:

var name = 'Jonatas Borges';

To make it observable, you just need to add ".obs" to the end of it:

var name = 'Jonatas Borges'.obs;

This borders on absurdity when it comes to practicality. What did we do under the hood? We created a stream of Strings, assigned the initial value "Jonatas Borges", we warn all widgets that use "Jonatas Borges" that they now belong to this variable, and when it is changed, they will be changed too. This is the magic of Get, that only dart allows us to do this.

Okay, but as we know, a widget can only be changed if it is inside a function, because static classes do not have the power to "auto-change". You will need to create a StreamBuilder, subscribe to listen to this variable, and create a "cascade" of StreamBuilder if you want to change several variables in the same scope, right? No, you don't need a StreamBuilder, but you are right about static classes.

Well, in the view we usually have a lot of boilerplate when we want to change a specific widget. With Get you can also forget about this Boilerplate. StreamBuilder? initialValue? builder? No, you just need to play this variable inside an Obx widget.

Obx (() => Text (;

What do you need to memorize? "Obx(() =>" You are just passing that widget through an arrow-function into an Obx. Obx is smart, and will only be changed if the value of name is changed. If name is "John" and you change it to "John", it will not have any changes on the screen, and Obx will simply ignore this change, and will not rebuild the widget, to save resources. Isn't that amazing?

What if I have 5 observable variables within an Obx? It will update when any of them are changed. And if I have 30 variables in a class, when I update one, will it update all variables that are in that class? No, just the specific widget that uses that variable. And if I machine-gun my observable variable 1 billion times with the same value, will I have freeze on the screen for unnecessary reconstructions? No, GetX only updates the screen when the variable changes on the screen, if the screen remains the same, it will not reconstruct anything.


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(). 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 .

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.


You have 3 ways to turn a variable into an observable. The first is using Rx{Type}.

var count = RxString();

The second is to use Rx and type it with Rx<Type>

var count = Rx<String>();

The third, more practical, easy, and incredible approach, is just to add an .obs to your variable.

var count = 0.obs;

// or Rxint count = 0.obs;
// or Rx<int> count = 0.obs;

As we know, Dart is now heading towards null safety. With that it is a good idea, from now on, you start to use your variables always with an initial value. Transforming a variable into an observable with an initial value with Get is the simplest and most practical approach that currently exists in Flutter. You will literally add a ".obs" to the end of your variable, and that’s it, you’ve made it observable, and its value will be the initial value, this is fantastic!

You can add variables, and if you want to type your widget to get your controller inside, you just need to use GetX widget instead of Obx

final count1 = 0.obs;
final count2 = 0.obs;
int get sum => count1.value + count2.value;
  builder: (value) {
    print("count 1 rebuild");
    return Text('${value.count1.value}');
  builder: (_) {
    print("count 2 rebuild");
    return Text('${_.count2.value}');
  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.

var isLogged = false.obs;

and then you check if a user is logged in to trigger an event in "ever".

  ever(isLogged, fireRoute);
  isLogged.value = await Preferences.hasToken();

fireRoute(logged) {
  if (logged) {;
  } else {;

if hasToken was false, there would be no change to isLogged, so ever would never be called. To avoid this type of behavior, the first change to an observable will always trigger an event, even if it is the same. You can remove this behavior if you want, using: isLogged.firstRebuild = false;

In addition, Get provides refined state control. You can condition an event (such as adding an object to a list), on a certain condition.

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:

class CountCtl extends GetxController {
  final count = 0.obs;

With a simple:


You could update the counter variable in your UI, regardless of where it is stored.

Where .obs can be used

You can transform anything on obs:

class RxUser {
  final name = "Camila".obs;
  final age = 18.obs;

class User {
  User({String name, int age});
  final rx = RxUser();

  String get name =>;
  set name(String value) => = value;

  int get age => rx.age.value;
  set age(int value) => rx.age.value = value;

void main() {
  final user = User();
  user.age = 23;
  user.rx.age.listen((int age) => print(age));
  user.age = 24;
  user.age = 25;

Note about Lists

Working with Lists using Get is the best and most enjoyable thing in the world. They are completely observable as are the objects within it. That way, if you add a value to a list, it will automatically rebuild the widgets that use it. You also don't need to use ".value" with lists, the amazing dart api allowed us to remove that, unfortunate primitive types like String and int cannot be extended, making the use of .value mandatory, but that won't be a problem if you work with gets and setters for these.

final list = List<User>().obs;
ListView.builder (
  itemCount: list.lenght

You don't have to work with sets if you don't want to. you can use the "assign 'and" assignAll "api. The "assign" api will clear your list, and add a single object that you want to start there. The "assignAll" api will clear the existing list and add any iterable objects that you inject into it.

Why i have to use .value?

We could remove the obligation to use 'value' to String and int 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.


Typing in Get using Bindings is unnecessary. you can use the Obx widget instead of GetX which only receives the anonymous function that creates a widget. Obviously, if you don't use a type, you will need to have an instance of your controller to use the variables, or use Get.find<Controller>() .value or to retrieve the value.


Workers will assist you, triggering specific callbacks when an event occurs.

/// Called every time the variable $_ is changed
ever(count1, (_) => print("$_ has been changed"));

/// Called only first time the variable $_ is changed
once(count1, (_) => print("$_ was changed once"));

/// Anti DDos - Called every time the user stops typing for 1 second, for example. 
debounce(count1, (_) => print("debouce$_"), time: Duration(seconds: 1));

/// Ignore all changes within 1 second.
interval(count1, (_) => print("interval $_"), time: Duration(seconds: 1));

Mixing the two state managers

Some people opened a feature request, as they wanted to use only one type of reactive variable, and the other mechanics, and needed to insert an Obx into a GetBuilder for this. Thinking about it MixinBuilder was created. It allows both reactive changes by changing ".obs" variables, and mechanical updates via update(). However, of the 4 widgets he is the one that consumes the most resources, since in addition to having a Subscription to receive change events from his children, he subscribes to the update method of his controller.

Extending GetxController is important, as they have life cycles, and can "start" and "end" events in their onInit() and onClose() methods. You can use any class for this, but I strongly recommend you use the GetxController class to place your variables, whether they are observable or not.

GetBuilder vs GetX vs Obx vs MixinBuilder

In a decade working with programming I was able to learn some valuable lessons.

My first contact with reactive programming was so "wow, this is incredible" and in fact reactive programming is incredible. However, it is not suitable for all situations. Often all you need is to change the state of 2 or 3 widgets at the same time, or an ephemeral change of state, in which case reactive programming is not bad, but it is not appropriate.

Reactive programming has a higher consumption of RAM consumption that can be compensated for by the individual workflow, which will ensure that only one widget is rebuilt and when necessary, but creating a list with 80 objects, each with several streams is not a good one idea. Open the dart inspect and check how much a StreamBuilder consumes, and you'll understand what I'm trying to tell you.

With that in mind, I created the simple state manager. It is simple, and that is exactly what you should demand from it: updating state in blocks in a simple way, and in the most economical way.

GetBuilder is very economical in RAM, and there is hardly a more economical approach than him (at least I can't imagine one, if it exists, please let us know).

However, GetBuilder is still a mechanical state manager, you need to call update() just like you would need to call Provider's notifyListeners().

There are other situations where reactive programming is really interesting, and not working with it is the same as reinventing the wheel. With that in mind, GetX was created to provide everything that is most modern and advanced in a state manager. It updates only what is necessary and when necessary, if you have an error and send 300 state changes simultaneously, GetX will filter and update the screen only if the state actually changes.

GetX is still more economical than any other reactive state manager, but it consumes a little more RAM than GetBuilder. Thinking about it and aiming to maximize the consumption of resources that Obx was created. Unlike GetX and GetBuilder, you will not be able to initialize a controller inside an Obx, it is just a Widget with a StreamSubscription that receives change events from your children, that's all. It is more economical than GetX, but loses to GetBuilder, which was to be expected, since it is reactive, and GetBuilder has the most simplistic approach that exists, of storing a widget's hashcode and its StateSetter. With Obx you don't need to write your controller type, and you can hear the change from multiple different controllers, but it needs to be initialized before, either using the example approach at the beginning of this readme, or using the Bindings class.

Dependency Management

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:

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


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:

Controller controller = Get.find();
//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.

And then you will be able to recover your controller data that was obtained back there:


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:

Get.lazyPut<Service>(()=> ApiMock());
/// ApiMock will only be called when someone uses Get.find<Service> for the first time

If you want to register an asynchronous instance, you can use Get.putAsync.

Get.putAsync<SharedPreferences>(() async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setInt('counter', 12345);
    return prefs;


  int count = Get.find<SharedPreferences>().getInt('counter');
  // out: 12345

To remove a instance of Get:



One of the great differentials of this package, perhaps, is the possibility of full integration of the routes, state manager and dependency manager. When a route is removed from the Stack, all controllers, variables, and instances of objects related to it are removed from memory. If you are using streams or timers, they will be closed automatically, and you don't have to worry about any of that. In version 2.10 Get completely implemented the Bindings API. Now you no longer need to use the init method. You don't even have to type your controllers if you don't want to. You can start your controllers and services in the appropriate place for that. The Binding class is a class that will decouple dependency injection, while "binding" routes to the state manager and dependency manager. This allows Get to know which screen is being displayed when a particular controller is used and to know where and how to dispose of it. In addition, the Binding class will allow you to have SmartManager configuration control. You can configure the dependencies to be arranged when removing a route from the stack, or when the widget that used it is laid out, or neither. You will have intelligent dependency management working for you, but even so, you can configure it as you wish.

How to use

class HomeBinding implements Bindings{

Your IDE will automatically ask you to override the "dependencies" method, and you just need to click on the lamp, override the method, and insert all the classes you are going to use on that route:

class HomeBinding implements Bindings{
  void dependencies() {
    Get.lazyPut<ControllerX>(() => ControllerX());
    Get.lazyPut<Service>(()=> Api());

Now you just need to inform your route, that you will use that binding to make the connection between route manager, dependencies and states.

There, you don't have to worry about memory management of your application anymore, Get will do it for you.

The Binding class is called when a route is called, you can create an "initialBinding in your GetMaterialApp to insert all the dependencies that will be created.

  initialBinding: SampleBind(),
  home: Home(),


Always prefer to use standard SmartManagement (full), you do not need to configure anything for that, Get already gives it to you by default. It will surely eliminate all your disused controllers from memory, as its refined control removes the dependency, even if a failure occurs and a widget that uses it is not properly disposed. The "full" mode is also safe enough to be used with StatelessWidget, as it has numerous security callbacks that will prevent a controller from remaining in memory if it is not being used by any widget, and disposition is not important here. However, if you are bothered by the default behavior, or just don't want it to happen, Get offers other, more lenient options for intelligent memory management, such as SmartManagement.onlyBuilders, which will depend on the effective removal of widgets using the controller. tree to remove it, and you can prevent a controller from being deployed using "autoRemove: false" in your GetBuilder/GetX. With this option, only controllers started in "init:" or loaded into a Binding with "Get.lazyPut" will be disposed, if you use Get.put or any other approach, SmartManagement will not have permissions to exclude this dependency. With the default behavior, even widgets instantiated with "Get.put" will be removed, unlike SmartManagement.onlyBuilders. SmartManagement.keepFactory is like SmartManagement.full, with one difference. SmartManagement.full purges the factories from the premises, so that Get.lazyPut() will only be able to be called once and your factory and references will be self-destructing. SmartManagement.keepFactory will remove its dependencies when necessary, however, it will keep the "shape" of these, to make an equal one if you need an instance of that again. Instead of using SmartManagement.keepFactory you can use Bindings. Bindings creates transitory factories, which are created the moment you click to go to another screen, and will be destroyed as soon as the screen-changing animation happens. It is so little time that the analyzer will not even be able to register it. When you navigate to this screen again, a new temporary factory will be called, so this is preferable to using SmartManagement.keepFactory, but if you don't want to create Bindings, or want to keep all your dependencies on the same Binding, it will certainly help you . Factories take up little memory, they don't hold instances, but a function with the "shape" of that class you want. This is very little, but since the purpose of this lib is to get the maximum performance possible using the minimum resources, Get removes even the factories by default. Use whichever is most convenient for you.


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:


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:

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:

Other Advanced APIs and Manual configurations

GetMaterialApp configures everything for you, but if you want to configure Get Manually using advanced APIs.

  navigatorKey: Get.key,
  navigatorObservers: [GetObserver()],

You will also be able to use your own Middleware within GetObserver, this will not influence anything.

  navigatorKey: Get.key,
  navigatorObservers: [GetObserver(], // Here
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.isBottomSheetOpen // check if bottomsheet is open

Get.removeRoute() // remove one route.

Get.until() // back repeatedly until the predicate returns true.

Get.offUntil() // go to next route and remove all the previous routes until the predicate returns true.

Get.offNamedUntil() // go to next named route and remove all the previous routes until the predicate returns true.

GetPlatform.isAndroid/isIOS/isWeb... //(This method is completely compatible with FlutterWeb, unlike the framework. "Platform.isAndroid")

Get.height / Get.width // Equivalent to the method: MediaQuery.of(context).size.height, but they are immutable. If you need a changeable height/width (like browser windows that can be scaled) you will need to use context.height and context.width

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.

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

  enableLog: true,
  defaultTransition: Transition.fade,
  opaqueRoute: Get.isOpaqueRouteDefault,
  popGesture: Get.isPopGestureEnable,
  transitionDuration: Get.defaultDurationTransition,
  defaultGlobalState: Get.defaultGlobalState,

  enableLog = true,
  defaultPopGesture = true,
  defaultTransition = Transitions.cupertino

Breaking changes from 2.0

1- Rx types: Before: StringX now: RxString

Before: IntX now: RxInt

Before: MapX now: RxMax

Before: ListX now: RxList

Before: NumX now: RxNum

Before: RxDouble now: RxDouble

RxController and GetBuilder now have merged, you no longer need to memorize which controller you want to use, just use GetxController, it will work for simple state management and for reactive as well.

2- NamedRoutes Before:

  namedRoutes: {
    '/': GetRoute(page: Home()),


  getPages: [
    GetPage(name: '/', page:()=> Home()),

Why this change? Often, it may be necessary to decide which page will be displayed from a parameter, or a login token, the previous approach was inflexible, as it did not allow this. Inserting the page into a function has significantly reduced the RAM consumption, since the routes will not be allocated in memory since the app was started, and it also allowed to do this type of approach:

GetStorage box = GetStorage();

  getPages: [
    GetPage(name: '/', page:(){  
      return box.hasData('token') ? Home() : Login();

This library will always be updated and implementing new features. Feel free to offer PRs and contribute to them.