TensorFlow: What It Is, Its Real History, and How to Use It
TensorFlow is Google’s “end-to-end platform for machine learning” — its own description, not marketing gloss, since the project genuinely spans training, mobile and browser inference, and production serving under one name. It was released as open source on 9 November 2015 by the Google Brain team, runs under the Apache 2.0 license, and its current stable release is 2.21.0.
This guide checks every fact against TensorFlow’s own documentation, Wikipedia’s sourced history, and the project’s GitHub release log, and uses code taken directly from TensorFlow’s own current beginner quickstart rather than reconstructed from memory.
Before TensorFlow, there was DistBelief
TensorFlow is Google’s second-generation internal machine learning system, not its first. Starting in 2011, Google Brain built DistBelief, a proprietary deep learning system that spread rapidly across Alphabet’s products. A team that included Jeff Dean refactored DistBelief into a faster, more general-purpose library — the result, released externally in 2015, was TensorFlow. The name itself describes what the library does: a neural network is a graph of operations on multidimensional arrays, and in this framework’s own terminology, those arrays are called tensors and the graph is the flow.
TensorFlow reached version 1.0.0 on 11 February 2017 — over a year after its public debut, which had shipped as a 0.x series while the API stabilized. In its earliest years, TensorFlow computations were static dataflow graphs: you defined the full computation first, then ran it in a separate session — a design built for production efficiency, not for the interactive, print-statement-driven workflow most Python developers were used to.
TensorFlow 2.0: an admission, not just an upgrade
The most honest sentence in TensorFlow’s own Wikipedia entry is worth quoting directly: as “TensorFlow’s market share among research papers was declining to the advantage of PyTorch,” Google announced a new major version in September 2019. TensorFlow 2.0’s headline change was TensorFlow eager — switching the default execution mode from the static computational graph to the same “define-by-run” style that Chainer had introduced and PyTorch had made popular: code runs immediately, line by line, debuggable with an ordinary Python debugger rather than a separate graph-inspection tool.
That’s a genuinely different story from Keras’s own backend history (Keras went multi-backend, then TensorFlow-only, then multi-backend again) and from PyTorch’s (eager from day one, compiled mode added later as an opt-in). TensorFlow started static, watched developers migrate to a framework that wasn’t, and changed its default rather than its position on the matter.
Building and training a real model
TensorFlow’s current beginner quickstart trains an image classifier on the MNIST handwritten-digit dataset, using tf.keras — TensorFlow’s bundled implementation of the Keras API discussed in our Keras guide:
import tensorflow as tf
print("TensorFlow version:", tf.__version__)
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0The model itself is a Sequential stack, exactly like the Keras examples elsewhere on this site — because it is Keras, running as TensorFlow’s own default high-level API:
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10)
])Compiling, training, and evaluating follow the same three calls covered in the Keras guide:
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer='adam', loss=loss_fn, metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test, verbose=2)Run as published, this reaches roughly 97.8% test accuracy in five epochs — TensorFlow’s own documented result, not a claim we’re asking you to take on faith. To turn the model’s raw output into probabilities rather than logits, TensorFlow chains a softmax layer onto the trained model rather than baking it into training:
probability_model = tf.keras.Sequential([
model,
tf.keras.layers.Softmax()
])TPUs: TensorFlow’s own hardware story
No other framework in this series has a matching chapter: Google built custom silicon specifically for TensorFlow. The Tensor Processing Unit (TPU), announced in May 2016, is an application-specific chip tuned for low-precision machine learning arithmetic; Google reported running TPUs in its data centers for over a year already at that point, delivering an order-of-magnitude better performance per watt than general-purpose hardware for these workloads.
The pace of the hardware itself is part of the story: the second generation (May 2017) delivered 180 teraflops per chip and 11.5 petaflops when 64 chips were organized into a pod; the third generation (May 2018) roughly doubled that to 420 teraflops per chip, added 128 GB of high-bandwidth memory, and pushed pod-level performance past 100 petaflops. A separate, much smaller Edge TPU (July 2018) brought the same design philosophy to phones and embedded devices, running models exported through TensorFlow Lite.
The compiler underneath: XLA, now shared
TensorFlow’s performance compiler, XLA (Accelerated Linear Algebra), used to be a TensorFlow-only implementation detail. It no longer is. XLA is now developed under the OpenXLA project, with Google, NVIDIA, AMD, Intel, Apple, Arm, Amazon, Meta, and Alibaba contributing — and it compiles models from TensorFlow, PyTorch, and JAX to run efficiently across GPUs, CPUs, and ML accelerators. It’s the same governance pattern PyTorch went through with its 2022 move to the Linux Foundation, and Keras went through with its 2023 return to multi-backend support: three separate frameworks, three separate moves toward shared, vendor-neutral infrastructure within about eighteen months of each other.
The ecosystem beyond the core library
TensorFlow’s own site organizes its ecosystem into libraries and extensions built to take a model from research to a running product:
- LiteRT (renamed from TensorFlow Lite in 2024) — on-device inference for mobile and embedded hardware, the runtime the Edge TPU targets
- TensorFlow.js — training and inference directly in the browser or Node.js, announced as version 1.0 in March 2018
- TensorFlow Extended (TFX) — production ML pipelines: data validation, transformation, training, and serving as one managed workflow
- TensorFlow Serving — a dedicated serving system for putting trained models into production behind an API
- TensorFlow Hub — a repository of pretrained, reusable model pieces
- TensorFlow Agents — reinforcement learning; Spotify has published on using it to train playlist-generating RL agents
- TensorFlow GNN — graph neural networks, for relational data like traffic networks or molecule structures
- TensorFlow Probability — probabilistic modeling and statistical inference on top of TensorFlow’s automatic differentiation
TensorFlow vs. Keras and PyTorch
Where TensorFlow actually differs from the other two frameworks in this series, now that all three run eager code by default:
- Scope. Keras is an API; PyTorch is a library; TensorFlow describes itself as a platform — and the ecosystem list above is the reason why. TFX, TF Serving, and LiteRT cover a production path that neither Keras nor PyTorch bundles as their own first-party project (PyTorch’s closest equivalent, TorchServe, is a smaller, separately maintained piece).
- Hardware. TPU access, natively and at scale, remains uniquely tied to TensorFlow and JAX through Google Cloud — PyTorch can target TPUs too, but it’s a secondary path, not the home turf.
- Mindshare. TensorFlow’s own team has publicly acknowledged losing research-paper share to PyTorch through the late 2010s; TensorFlow 2.0 was a direct response, not an unrelated upgrade.
- Where they meet.
tf.kerasis Keras — the same API discussed in our Keras guide, bundled as TensorFlow’s default. Learning Keras’sSequentialand functional APIs already teaches you TensorFlow’s own recommended way to define a model.
Frequently asked questions
Who created TensorFlow, and when?
The Google Brain team, released as open source on 9 November 2015, as a refactor of Google’s earlier internal system, DistBelief.
Is TensorFlow still graph-based, or does it run eagerly now?
It runs eagerly by default since TensorFlow 2.0 (September 2019). The static-graph-first design describes TensorFlow 1.x, not the current framework — though a graph can still be compiled explicitly via tf.function for production performance.
Is TensorFlow the same as Keras?
No, but they’re closely tied: tf.keras is TensorFlow’s own bundled implementation of the Keras API, and it’s the officially recommended way to define models in TensorFlow. Keras itself, since version 3 (2023), can also run on PyTorch or JAX instead.
What’s the difference between TensorFlow Lite and LiteRT?
None functionally — LiteRT is TensorFlow Lite’s new name, adopted in 2024. Existing TensorFlow Lite models and code continue to work under the new name.
Do you need a TPU to use TensorFlow?
No. TensorFlow runs on ordinary CPUs and NVIDIA GPUs; TPUs are Google’s own accelerator, available through Google Cloud, and matter mainly at large training scale rather than for typical development.
Related
- Keras: What It Is, How It Works, and How to Use It in 2026, the API that
tf.kerasimplements - PyTorch: What It Is, Its Real History, and How to Use It, the framework TensorFlow 2.0 was built to compete with
- PyTorch vs. TensorFlow Frameworks, a direct head-to-head
- Neural network and fine-tuning in the glossary