Deep Learning βΊ Training at Scale βΊ Day 233
Day 233: Mixed Precision and Performance
Master mixed-precision acceleration and deep learning performance engineering: understand FP32, FP16, BF16, and FP8 numerical formats, implement PyTorch Automatic Mixed Precision (AMP) with autocast and dynamic loss scaling (GradScaler), analyze training VRAM memory allocation across weights and optimizer states, optimize execution with torch.compile, and build a high-throughput benchmarking suite.
Hands-on lab for this lesson
Lab files on GitHub: https://github.com/ai-roadmap-365/ai-roadmap-365.github.io/tree/main/labs/sections/deep-learning/day-233-mixed-precision-and-performance
- Get the hands-on files. Clone the labs repository once (you can reuse this clone for every lesson). This works on macOS, Linux, and Windows (PowerShell or WSL):
git clone https://github.com/ai-roadmap-365/ai-roadmap-365.github.io.git cd ai-roadmap-365.github.io - Open this lesson's lab. Move into the directory for this specific day. Every lab lives at the same predictable path β section / subsection / week / day:
cd labs/sections/deep-learning/day-233-mixed-precision-and-performance - Read the lab guide. Open `README.md` in that directory. It lists the exact commands, what each does, the expected output, and how to check your work β read it before running anything.
- Run it and check your work. Follow the README's "How to run" section: run the example first to see the finished result, then complete the numbered exercises in `starter/`, then run the tests. The tests pass (exit 0) only when your work is correct.
bash tests/run_tests.sh # or the test command named in the lab README
You can also open the lab as a local page (works offline, shows the file tree and expected output).
Learning objectives
By the end of this lesson you will be able to:
- Compare floating-point numerical representations: IEEE 754 FP32, FP16, Google BF16, and NVIDIA FP8 (E4M3/E5M2).
- Implement Automatic Mixed Precision (AMP) in PyTorch using torch.autocast and GradScaler.
- Explain gradient underflow in FP16 and derive the dynamic loss scaling algorithm.
- Calculate exact GPU VRAM memory breakdown during mixed-precision AdamW training.
- Apply PyTorch 2.0 torch.compile graph capture and kernel fusion to eliminate memory bandwidth bottlenecks.
Prerequisites
Why this matters
For decades, scientific computing relied exclusively on IEEE 754 32-bit Single Precision (FP32) and 64-bit Double Precision (FP64).
However, deep neural networks possess an astonishing mathematical property: Robust Graceful Precision Tolerance:
- A neural network does not need 23 bits of decimal precision to recognize a cat or generate Python code.
- By switching from FP32 (4 bytes per number) to 16-bit Half Precision (FP16/BF16):
- Memory traffic across High Bandwidth Memory is cut by
50\%. - Model VRAM footprints drop by
50\%, allowing2\timeslarger batch sizes. - Dedicated Tensor Cores execute matrix multiplications
2\timesto5\timesfaster.
- Memory traffic across High Bandwidth Memory is cut by
Today, training frontier models entirely in FP32 is obsolete. Every major AI laboratory uses Automatic Mixed Precision (AMP), Bfloat16, and FP8 Transformer Engines.
Today, you will master the bit-level anatomy of floating-point representations, dynamic loss scaling (GradScaler), VRAM memory budget calculations, and PyTorch 2.0 torch.compile kernel fusion.
The idea in plain language
Think of writing notes during a fast-paced university lecture:
- FP32 Full Precision: You write every word in pristine Oxford English with a calligraphy fountain pen on thick parchment paper (Slow, bulky, maximum precision). Your hand cramps, and your notebook fills up in 20 minutes.
- Mixed Precision (FP16 / BF16): You write rapid shorthand abbreviations on a lightweight legal pad (
3\timesfaster, half the paper). - Master Weights (The Final Clean Transcript): At the end of the day, you transfer your shorthand notes into a clean, permanent leather-bound binder in full detail (FP32 Master Copy).
You get 100\% of the lecture content recorded in real-time with zero loss in factual accuracy!
Historical background
- 2017 (Micikevicius et al. & Mixed Precision Training): NVIDIA published the foundational paper establishing that training deep networks in FP16 with FP32 master weights and loss scaling achieved identical validation accuracy to FP32 baselines.
- 2018 (Google TPU v2 & Bfloat16): Google created Bfloat16 (Brain Floating Point), truncating FP32 mantissa while preserving its full 8-bit exponent, eliminating loss scaling entirely.
- 2022 (NVIDIA Hopper H100 & FP8 Transformer Engine): Introduced native 8-bit floating-point Tensor Cores, doubling throughput over FP16.
- 2023 (PyTorch 2.0 &
torch.compile): Replaced manual CUDA kernel engineering with JIT graph capture and automated Triton kernel fusion.
What it is β and what it is not
What Automatic Mixed Precision (AMP) IS:
- Selective Precision Dispatch: Automatically executing computationally intensive GEMMs (Linear, Conv) in fast 16-bit precision while keeping sensitive reductions (Softmax, LayerNorm, Loss) in stable 32-bit precision.
- Loss Scaling & Master Weights: Maintaining full-precision parameters in the optimizer to accumulate tiny gradient updates without numerical truncation.
What it is NOT:
- Not Naive Type-Casting: Simply calling
model.half()converts all layers naively to FP16, which causes catastrophic training divergence due to Softmax overflow and LayerNorm variance underflow.
Why it was created and what problems it solves
Mixed Precision solved the twin bottlenecks of AI scaling:
- Memory Bandwidth Saturation: Halving byte size instantly doubles effective memory bandwidth across the bus.
- GPU VRAM Capacity Limits: Enables training models twice as large on existing physical hardware.
- Silicon Energy Efficiency: 16-bit and 8-bit ALUs consume a fraction of the physical silicon area and electrical energy of 32-bit ALUs.
How it works
Let us dissect floating-point numerical structures, loss scaling algorithms, and VRAM memory mathematics.
1. Anatomy of Floating-Point Representations
A floating point number represents a real value via:
\text{Value} = (-1)^{\text{sign}} \times 2^{\text{exponent} - \text{bias}} \times (1 + \text{mantissa})
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β FLOATING POINT BITWISE COMPARISON β
ββββββββββββββββββββββ¬βββββββββββ¬βββββββββββββββ¬βββββββββββ¬βββββββββββββββ€
β Format β Sign Bit β Exponent (E) β Mantissa β Dynamic Rangeβ
ββββββββββββββββββββββΌβββββββββββΌβββββββββββββββΌβββββββββββΌβββββββββββββββ€
β FP32 (Single) β 1 bit β 8 bits β 23 bits β ~1e-38 to 3e38β
β FP16 (Half) β 1 bit β 5 bits β 10 bits β ~6e-8 to 65504β
β BF16 (Bfloat16) β 1 bit β 8 bits β 7 bits β ~1e-38 to 3e38β
β FP8 (E4M3) β 1 bit β 4 bits β 3 bits β ~0.002 to 448β
β FP8 (E5M2) β 1 bit β 5 bits β 2 bits β ~6e-8 to 57344β
ββββββββββββββββββββββ΄ββββββββββββββββββ΄βββββββββββββββββββ΄βββββββββββββββ
Why BF16 Beat FP16:
- In FP16, the minimum positive normal value is
2^{-14} \approx 6.1 \times 10^{-5}(and subnormal min is6 \times 10^{-8}). Gradients in deep transformers routinely drop below10^{-7}, causing catastrophic Gradient Underflow (vanishing to zero). - BF16 has the exact same 8-bit exponent as FP32, matching its massive dynamic range (
10^{-38}to10^{38}), completely eliminating underflow without requiring loss scalers!
2. Automatic Mixed Precision (AMP) Workflow & GradScaler
When using FP16, the GradScaler manages dynamic loss scaling:
-
Forward Pass (autocast): Executes linear projections in FP16; outputs loss
\mathcal{L}in FP32. -
Dynamic Loss Scaling: Multiplies loss by scale factor
S(initialized toS = 65,536):\mathcal{L}_{\text{scaled}} = \mathcal{L} \times S -
Backward Pass: Computes scaled gradients
g_{\text{scaled}} = g \times Sin FP16 (shifted away from zero underflow). -
Unscaling & Inf/NaN Checking:
g = \frac{g_{\text{scaled}}}{S}- If any gradient contains
InforNaN(overflow detected), the optimizer step is skipped, and the scaler shrinksS \leftarrow S / 2. - If
Nconsecutive steps succeed without overflow (e.g.N=2000), the scaler growsS \leftarrow S \times 2.
- If any gradient contains
-
Master Weight Update: Applies
gto the FP32 Master Weights, and copies updated parameters back to FP16 for the next forward pass.
3. Exact GPU VRAM Breakdown for Mixed-Precision AdamW
When training an N-parameter model in mixed-precision AdamW:
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β VRAM MEMORY BREAKDOWN (PER PARAMETER IN ADAMW) β
ββββββββββββββββββββββ¬βββββββββββ¬βββββββββββββββ¬ββββββββββββββββββββββββββ€
β Component β Data Typeβ Bytes / Paramβ Example (7B Model) β
ββββββββββββββββββββββΌβββββββββββΌβββββββββββββββΌββββββββββββββββββββββββββ€
β Model Parameters β FP16/BF16β 2 Bytes β 14 GB β
β Gradients β FP16/BF16β 2 Bytes β 14 GB β
β Master Weights β FP32 β 4 Bytes β 28 GB β
β Adam First Moment β FP32 β 4 Bytes β 28 GB β
β Adam Second Moment β FP32 β 4 Bytes β 28 GB β
ββββββββββββββββββββββΌβββββββββββΌβββββββββββββββΌββββββββββββββββββββββββββ€
β TOTAL STATIC STATE β β 16 Bytes β 112 GB β
ββββββββββββββββββββββ΄βββββββββββ΄βββββββββββββββ΄ββββββββββββββββββββββββββ
- Rule of Thumb: A model requires
16 \times NBytes of static VRAM just for weights, gradients, and optimizer states, plus dynamic activation memory!
4. Kernel Fusion with torch.compile (PyTorch 2.0)
In uncompiled PyTorch, executing:
y = F.gelu(x @ W + b) + residual
launches 4 separate GPU kernels:
- Matrix multiplication: Reads
x, W \rightarrowwrites temp1 to HBM. - Bias addition: Reads temp1,
b \rightarrowwrites temp2 to HBM. - GELU activation: Reads temp2
\rightarrowwrites temp3 to HBM. - Residual addition: Reads temp3, residual
\rightarrowwritesyto HBM.
torch.compile(model) with TorchInductor:
- Fuses all four steps into a single Triton kernel.
- Intermediate results stay in SRAM Shared Memory / Registers, cutting memory traffic by
75\%and speeding up execution by30\%to50\%!
5. Microscaling Formats (MXFP8, MXFP6, MXFP4 / OCP Standard)
As models scale past 100 billion parameters, standard FP8 encounters precision degradation in outlier activations:
- Microscaling (MX) Formats: Developed by AMD, Arm, Intel, Meta, NVIDIA, and Qualcomm via the Open Compute Project.
- Shared Block-Level Scaling: Rather than assigning a single scale factor to an entire tensor, MX groups 32 consecutive elements into a micro-block, sharing a single 8-bit scale factor (E8M0).
- Result: Delivers sub-8-bit quantization (FP6 and FP4) during pretraining with mathematical fidelity matching full FP16 baselines!
6. Activation Checkpointing (Gradient Checkpointing / Chen et al., 2016)
While weights and optimizer states are static, Intermediate Forward Activations grow linearly with sequence length L and batch size B:
-
The Activation Dilemma: In standard backpropagation, every intermediate tensor computed during the forward pass must be retained in VRAM until its corresponding layerβs backward pass. For long sequences (
L \ge 8,192), activations consume80\%+of total VRAM! -
Gradient Checkpointing: Only stores activations at the boundaries of Transformer blocks (e.g. 1 per layer). During the backward pass, it re-executes the forward pass of that single block on-the-fly:
\text{Memory Complexity: } O(N) \longrightarrow O(\sqrt{N}) -
Trade-off: Saves up to
70\%of dynamic VRAM, allowing4\timeslonger context windows at the cost of only25\%to33\%extra compute.
7. 8-Bit Optimizers: 8-bit Adam (Dettmers et al., 2021)
Standard mixed-precision AdamW maintains 8 bytes per parameter for momentum and variance in FP32:
- 8-Bit Adam (bitsandbytes): Non-linearly quantizes the first and second moments into block-wise 8-bit representations.
- VRAM Savings: Slashes optimizer memory from
8 \times NBytes\rightarrow 2 \times NBytes (a75\%reduction in optimizer state size) with zero loss in training convergence or final perplexity!
8. Custom Autocast Layer Registration
When implementing custom CUDA or C++ extensions in PyTorch, standard autocasting does not know how to handle your functions:
- Use
@torch.amp.custom_fwd(cast_inputs=torch.float16)and@torch.amp.custom_bwddecorators. - Ensures forward arguments are automatically downcast to FP16/BF16 while backward gradients are safely processed in FP32.
- NVIDIA Transformer Engine: Uses delayed scaling to predict optimal FP8 exponent biases across consecutive training iterations without stalling GPU execution pipes. This ensures zero-overhead automatic FP8 quantization.
An everyday analogy
Think of a commercial cargo airplane fleet:
- FP32 Training: Packing cargo in heavy cast-iron crates (4 kg per item). The airplane can only carry 1,000 crates before hitting maximum payload weight (Out of Memory).
- Mixed Precision Training: Packing the same cargo in ultra-light aerospace carbon-fiber containers (2 kg per item).
- The plane now carries 2,000 containers per flight (
2\timesLarger Batch Size). - Fuel consumption is cut in half (
50\%Memory Traffic). - Unloading speed at the terminal is doubled (
2\timesTensor Core Throughput).
- The plane now carries 2,000 containers per flight (
Examples in practice
Let us build a Complete Mixed-Precision Training Benchmark in PyTorch:
import torch
import torch.nn as nn
import time
class BenchmarkMLP(nn.Module):
def __init__(self, dim: int = 2048):
super().__init__()
self.fc1 = nn.Linear(dim, dim * 4)
self.act = nn.GELU()
self.fc2 = nn.Linear(dim * 4, dim)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return x + self.fc2(self.act(self.fc1(x)))
def run_mixed_precision_benchmark(batch_size: int = 64, dim: int = 2048,
steps: int = 20) -> dict:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = BenchmarkMLP(dim).to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
scaler = torch.amp.GradScaler("cuda", enabled=(device.type == "cuda"))
inputs = torch.randn(batch_size, dim, device=device)
targets = torch.randn(batch_size, dim, device=device)
criterion = nn.MSELoss()
# Warmup
for _ in range(5):
optimizer.zero_grad()
with torch.amp.autocast(device_type=device.type, dtype=torch.float16, enabled=(device.type == "cuda")):
outputs = model(inputs)
loss = criterion(outputs, targets)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
if device.type == "cuda":
torch.cuda.synchronize()
# Timed benchmark loop
start = time.perf_counter()
for _ in range(steps):
optimizer.zero_grad()
with torch.amp.autocast(device_type=device.type, dtype=torch.float16, enabled=(device.type == "cuda")):
outputs = model(inputs)
loss = criterion(outputs, targets)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
if device.type == "cuda":
torch.cuda.synchronize()
elapsed = (time.perf_counter() - start) / steps
return {
"batch_size": batch_size,
"step_latency_ms": round(elapsed * 1000, 3),
"scaler_scale": scaler.get_scale() if device.type == "cuda" else 1.0
}
Implications: security, privacy, performance, scalability, and cost
- Numerical Stability & NaN Cascades:
- In FP16, a single activation exceeding
65,504producesInf. In LayerNorm,\text{Inf} - \text{Inf} = \text{NaN}, which instantly infects all model weights in the next optimizer step. - Remedy: Always use BF16 on Ampere/Hopper GPUs, or maintain conservative gradient clipping (
max_norm=1.0) in FP16.
- In FP16, a single activation exceeding
- Energy Efficiency in Green AI:
- Switching large LLM pretraining from FP32 to BF16/FP8 slashes total datacenter energy consumption by
60\%, saving megawatts of electricity and millions of dollars in utility bills.
- Switching large LLM pretraining from FP32 to BF16/FP8 slashes total datacenter energy consumption by
Alternatives: free, open source, and commercial
| Precision Mode | Hardware Support | Loss Scaler Required? | Relative Speed | Stability |
|---|---|---|---|---|
| FP32 | Universal (CPUs/GPUs) | No | 1.0\times Baseline | Rock Solid |
| FP16 | Volta / Turing / Ampere | Yes (Mandatory) | 2.0\times - 3.0\times | Moderate (Underflow risk) |
| BF16 | Ampere / Hopper / TPU | No | 2.0\times - 3.0\times | Rock Solid (SOTA Standard) |
| FP8 | Hopper H100 / Blackwell | Adaptive scaling | 4.0\times - 5.0\times | High with scaling |
Comparison with related concepts
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β PRECISION FORMAT COMPARISON SUMMARY β
ββββββββββββββββββββββ¬ββββββββββββββββββ¬βββββββββββββββββββ¬βββββββββββββββ€
β Format β Exponent Bits β Mantissa Bits β Dynamic Rangeβ
ββββββββββββββββββββββΌββββββββββββββββββΌβββββββββββββββββββΌβββββββββββββββ€
β FP32 β 8 bits β 23 bits β 10^{38} β
β FP16 β 5 bits β 10 bits β 10^4 (Narrow)β
β BF16 β 8 bits β 7 bits β 10^{38} (Wide)β
β FP8 (E4M3) β 4 bits β 3 bits β 10^2 (Micro) β
ββββββββββββββββββββββ΄ββββββββββββββββββ΄βββββββββββββββββββ΄βββββββββββββββ
When to use it β and when not to
When to USE Mixed Precision (BF16/FP16):
- Every production neural network training run, LLM pretraining, fine-tuning, and high-throughput inference serving.
When NOT to use:
- Highly sensitive scientific simulations (e.g. quantum chemistry, astronomical orbit integration) where 23+ bits of fractional precision are strictly required.
The AI connection
- Mixed precision roughly doubled effective training capacity without any change to the model, which is why nearly every modern run uses it.
- The format that won was chosen for range, not precision β matching the exponent of full precision mattered more than matching the mantissa.
- Numerical stability is a real engineering discipline in AI, not a footnote: the wrong format silently produces zeros rather than an error.
- Memory, not compute, usually sets the largest trainable model, so optimiser state and activation strategies decide what is feasible.
- Compilation and kernel fusion have become standard, moving performance work from hand-written kernels to the framework.
Knowledge check
- Why does BF16 eliminate the need for dynamic loss scaling compared to FP16?
- What happens during a
GradScalerstep if anInforNaNgradient is detected? - How many bytes of static VRAM per parameter are required by mixed-precision AdamW?
- How does
torch.compileeliminate HBM memory traffic via kernel fusion? - What are the roles of E4M3 vs E5M2 formats in FP8 training?
Hands-on exercise
In this lab, you will build and test a modular mixed-precision simulation and VRAM memory profiling engine in PyTorch: implement precision bitwise representations, compute exact static AdamW VRAM allocation formulas, construct a simulated dynamic loss scaling engine with overflow detection, and verify training throughput acceleration.
Expected output
[Mixed Precision and Performance Verification Suite]
Testing VRAM Memory Budget Profiler:
Model Size: 7.0 Billion Parameters
Static VRAM Allocation (Mixed Precision AdamW): 112.00 GB [EXACT MATCH]
Testing Dynamic Loss Scaling Simulator:
Initial Scale Factor: 65536.0
Normal Step: Scale maintained (65536.0)
Overflow Detected (Inf Gradient): Scale backoff to 32768.0 [OVERFLOW CAUGHT]
Testing Bitwise Numerical Properties:
BF16 Exponent Bits: 8 (Matches FP32 dynamic range) [VERIFIED]
Test Suite: 3 passed in 0.42s
Validate your work
Run the automated test runner:
./tests/run_tests.sh
Troubleshooting
- When using
torch.amp.autocast, specifydevice_type="cuda"or"cpu"rather than passing raw device objects.
Common mistakes
- Calling
optimizer.step()instead ofscaler.step(optimizer): Bypasses unscaling and corrupts master weights with scaled gradients.
Practice assignment
- Implement a VRAM Memory Budget Calculator function that accepts model parameters, sequence length, batch size, and returns peak activation + static memory estimates.
- Benchmark
torch.compileon a 6-layer Transformer block in PyTorch.
Extension challenge
Implement FP8 Simulated Quantization in PyTorch:
- Implement E4M3 scale-factor clamping and simulate FP8 matrix multiplication.
- Compare output relative error against FP16 baseline.
Quiz
Q1. Why does Bfloat16 (BF16) avoid the gradient underflow issues that affect standard FP16 during deep neural network training?
- BF16 eliminates negative numbers
- BF16 uses integer arithmetic instead of floating point
- BF16 keeps FP32's exponent range, so gradients survive
- BF16 requires 64 bits of storage
Show answer
Answer: C. BF16 keeps FP32's exponent range, so gradients survive
BF16 preserves FP32 wide 8-bit dynamic range, eliminating the need for loss scaling during training.
Q2. What is the purpose of the GradScaler in PyTorch Automatic Mixed Precision (AMP) with FP16?
- It shrinks the vocabulary size
- It scales up the learning rate by 10x
- It doubles the batch size
- It scales the loss before backward
Show answer
Answer: D. It scales the loss before backward
GradScaler prevents small backpropagation gradients from underflowing to zero in 16-bit half precision.
Q3. How much GPU VRAM does a 7-billion parameter model require just to store training states in mixed-precision AdamW?
- 112 GB
- 7 GB
- 1 GB
- 500 MB
Show answer
Answer: A. 112 GB
Mixed-precision AdamW requires 16 bytes per parameter (2B model + 2B grad + 4B master + 4B moment 1 + 4B moment 2), totaling 112 GB for 7B parameters.
Q4. What is the primary optimization performed by torch.compile (PyTorch 2.0 TorchDynamo / Inductor)?
- It translates Python into Java
- It fuses ops into one kernel
- It compresses dataset text
- It disables backpropagation
Show answer
Answer: B. It fuses ops into one kernel
torch.compile automatically fuses elementwise kernels, keeping activations in fast SRAM and bypassing HBM bandwidth limits.
Q5. What are the two distinct FP8 numerical variants defined for deep learning (Hopper/Blackwell architecture)?
- FP8-CPU and FP8-GPU
- FP8-Left and FP8-Right
- E4M3 and E5M2
- FP8-Int and FP8-Float
Show answer
Answer: C. E4M3 and E5M2
E4M3 maximizes precision for forward passes; E5M2 maximizes dynamic range to capture gradient distributions.
Glossary
- Automatic Mixed Precision (AMP)
- A framework executing performance-critical matrix operations in 16-bit half precision while maintaining 32-bit master weights for stability.
- GradScaler
- A dynamic loss scaling engine that multiplies loss by a scale factor to prevent gradient underflow during FP16 backward passes.
- Bfloat16 (BF16)
- A 16-bit floating point format with 1 sign bit, 8 exponent bits (matching FP32 range), and 7 mantissa bits.
- FP8 (E4M3 / E5M2)
- An 8-bit floating point format delivering double the throughput of 16-bit on modern NVIDIA Hopper and Blackwell architectures.
- Kernel Fusion
- Combining multiple sequential operations into a single GPU kernel to eliminate intermediate memory reads and writes across HBM.
- torch.compile
- The PyTorch 2.0 JIT compiler utilizing TorchDynamo and TorchInductor to optimize PyTorch code into high-speed Triton/C++ kernels.
- Master Weights
- A full-precision FP32 copy of model parameters maintained by the optimizer to accumulate small parameter updates.
- Gradient Underflow
- The numerical failure when small backpropagation gradients drop below the minimum representable value of FP16 and vanish to zero.
Sources and further reading
- Mixed Precision Training β ICLR 2018 (accessed 2026-08-29)
- BFloat16: The Secret to High Performance on Cloud TPUs β Google Cloud Tech (accessed 2026-08-29)
- PyTorch 2: Faster Machine Learning Through Dynamic Python Bytecode Transformation and JIT Compilation β PyTorch Foundation (accessed 2026-08-29)
Kept in this browser, no account needed. Your progress page turns the whole record into one link you can bookmark or open on another device.