Refresh landing page to current Forgather capabilities

Replace alpha-era aspirational framing with concrete current capabilities
and headline experiment results: framework-portable model export,
pipeline parallelism over 1 Gbit Ethernet, full-param 7B finetune at
53K context on a 24 GB GPU, Adafactor with bf16 stochastic rounding,
GPU-aware web UI, live job control. Add links to the long-context
Lovecraft, optimizer comparison, peak-memory ablation, pretraining,
and Samantha finetune experiments. Tighten metadata description for
search.

Remove broken header_pages references in _config.yml (the four target
pages don't exist).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jdinalt

_config.yml

@@ -31,13 +31,6 @@ repository: jdinalt/forgather
 # Theme
 theme: minima
 
-# Navigation
-header_pages:
-  - getting-started.md
-  - features.md
-  - examples.md
-  - docs.md
-
 # Collections
 collections:
   examples:

index.md

@@ -1,67 +1,107 @@
 ---
 layout: home
-title: "Forgather: Democratizing Large Model Experimentation"
-description: "Alpha-stage ML framework bringing distributed pipeline parallelism to consumer GPUs. Seeking collaborators to help develop the future of accessible AI training."
+title: "Forgather: Configuration-Driven ML Framework for Consumer-GPU Training"
+description: "Forgather is a PyTorch ML framework with template-inheritance configs, framework-portable model export, pipeline parallelism for bandwidth-limited setups, and full-parameter 7B finetuning on a single 24 GB GPU."
 ---
 
-# Democratizing Large Model Experimentation
+# Forgather
 
-[**Forgather**](https://github.com/jdinalt/forgather) is an alpha-stage ML framework that aims to make large model training accessible to hobbyists and researchers with consumer hardware.
+[**Forgather**](https://github.com/jdinalt/forgather) is a configuration-driven ML framework built on template inheritance and code generation. It targets the gap between "research script that grows ten near-copies of itself" and "production framework you can't customise without forking."
 
-## The Vision
+The framework is open source, runs on PyTorch, and has been in active development since 2023.
 
-### **Pipeline Parallelism for Consumer GPUs**
-Enable training of models larger than single GPU memory by distributing them across multiple consumer-grade cards using [Torch Distributed Pipeline Parallelism](https://docs.pytorch.org/docs/main/distributed.pipelining.html) Our goal is to make 7B+ parameter full model training accessible without enterprise hardware.
+## What's actually in the box
 
-### **End Configuration Duplication**
-Eliminate the copy-paste cycle of ML experiments through a powerful template inheritance system. Specify only what changes between experiments, not entire configurations.
+### Template-inheritance configs, no copy-paste
 
-### **Framework-Independent Models**
-Generate standalone Python code that works without dependencies on Forgather itself. Your trained models remain portable and deployable anywhere.
+A Forgather project config extends a parent. Both are plain YAML with Jinja2 preprocessing, and *every knob* is an explicitly overridable block. To try a longer context window or a different optimizer, you write the override; the rest is inherited. Custom YAML tags (`!partial`, `!factory`, `!singleton`) let you swap in any Python class or function without touching Python source.
 
-## Current Status: Alpha
+### Models that don't depend on Forgather
 
-Forgather is in active development with core functionality implemented:
+Each training run writes the equivalent PyTorch source into `output_models/`. The generated code has no Forgather dependency:
 
-- Template inheritance system working
-- Pipeline parallelism implemented  
-- Code generation pipeline functional
-- Multi-GPU distributed training
-- Performance optimization ongoing
-- Documentation and examples expanding
+```python
+from transformers import AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained(
+    "output_models/my_run",
+    trust_remote_code=True,
+)
+```
 
-## Seeking Collaborators
+`forgather convert --reverse` will additionally emit a canonical Hugging Face checkpoint (Llama / Mistral / Qwen3 / Gemma-3) that loads without `trust_remote_code`. Train in Forgather, deploy anywhere.
 
-We're looking for contributors who share our vision of democratizing AI:
+### Pipeline parallelism for bandwidth-limited setups
 
-### **Researchers & Experimenters**
-Help test pipeline parallelism with different model architectures and share your findings.
+The pipeline trainer (GPipe, 1F1B, Interleaved-1F1B, zero-bubble schedules) needs dramatically less cross-device communication than DDP or FSDP. Concrete results:
 
-### **ML Engineers**  
-Contribute to performance optimization, memory efficiency, and distributed training improvements.
+- **7B-parameter model trained across two machines connected by 1 Gbit Ethernet**, with bandwidth to spare.
+- The same design avoids PCIe stalls that bottleneck FSDP on consumer GPUs without NVLink.
+- DDP (with optional Post-Local-SGD), FSDP-2, and DiLoCo (Distributed Low-Communication Training, [arXiv:2311.08105](https://arxiv.org/abs/2311.08105)) are also first-class.
 
-### **Documentation & Examples**
-Help create tutorials, guides, and example configurations for the community.
+### Full-parameter 7B finetuning on a single 24 GB GPU
 
-### **Core Development**
-Contribute to framework architecture, code generation, and template systems.
+Not LoRA — full parameter, up to **~53 K tokens of context** on a single RTX 4090. Achieved by combining gradient checkpointing, CPU activation offload, fused optimizer step, fused linear + cross-entropy loss (Liger / Apple CCE / `torch.compile`), and packed sequences with Flex Attention.
 
-## What We're Building
+A documented 9-way ablation of these techniques on a 1.6 B model showed an **81 % peak-memory reduction at ~2.7× throughput** versus the naive baseline. ([peak-memory experiment](https://github.com/jdinalt/forgather/tree/main/examples/tiny_experiments/peak_memory))
 
-- **Accessible Training**: 7B+ models on consumer setups
-- **Template-Driven**: Systematic experimentation without configuration chaos
-- **Pipeline Parallelism**: Much faster than FSDP on hardware lacking a fast interconnect
-- **Framework Freedom**: Generated models work independently
-- **Research Focus**: Built for exploration and comparison
+### Adafactor + AdamW with bf16 stochastic rounding
 
-## Early Results
+Forgather ships a fused Triton Adafactor that combines factored second-moment estimation with per-parameter stochastic rounding for bf16 weight updates, in a single kernel. To our knowledge this is the only Adafactor+SR implementation available, and it runs faster than every reference Adafactor we've benchmarked. SR is critical for *pure*-bf16 training (no fp32 master weights) — without it, sub-precision updates round systematically to zero and weight norms drift.
 
-Initial testing on 4x RTX 4090 setup shows promising results for 7B parameter model training with various pipeline schedules. We're particularly excited about zero-bubble pipeline performance, though optimization work continues.
+### Web UI with GPU-aware job queue
 
-[Explore the Code →](https://github.com/jdinalt/forgather){: .btn .btn-primary}
-[Join Discussions →](https://github.com/jdinalt/forgather/discussions){: .btn .btn-outline}
-[Report Issues →](https://github.com/jdinalt/forgather/issues){: .btn .btn-outline}
+A single-user browser frontend over the same APIs as the CLI: project / file browsing, ▶ Run buttons that drop training jobs into a priority + GPU-policy queue, live job cards with TTY and training-stat pills, per-card process attribution, an in-browser editor with Forgather YAML+Jinja2 syntax highlighting, and a chat client wired to served inference jobs.
 
----
+### Live job control across distributed workers
+
+```bash
+forgather control list
+forgather control save JOB_ID        # save checkpoint on demand
+forgather control save-stop JOB_ID   # save and gracefully stop
+forgather control abort JOB_ID       # kill a failed experiment without saving
+```
+
+Distributed-safe — commands sent to any rank are coordinated across all DDP / FSDP-2 / pipeline workers.
+
+### Reproducibility built in
+
+Every run snapshots its full config *and* the generated model source. Resume restores optimizer state, LR scheduler, dataset position (stateful resume on C4-scale corpora is fast), RNG, and Tensorboard logs. Distributed checkpoints are written as standard HF Safetensors shards readable by `transformers`, vLLM, and llama.cpp conversion tools.
+
+## Worked examples worth reading
+
+These aren't toy demos — each has a README with reproducible commands and headline results:
+
+- **[Long-context Lovecraft finetune + RoPE comparison](https://github.com/jdinalt/forgather/tree/main/examples/tutorials/hp_lovecraft_project)** — Mistral-7B / Llama-2-7B on the complete works of H. P. Lovecraft on a single 24 GB GPU, 53 K context. Companion document compares plain RoPE, YaRN, Llama-3 NTK-by-parts, and bumped `rope_theta`. Headline finding: **bumping `rope_theta` to 500 000 is the single biggest intervention for context extrapolation**.
+
+- **[Optimizer comparison on a 30 M Llama](https://github.com/jdinalt/forgather/tree/main/examples/tiny_experiments/optimizers)** — empirical comparison of ten optimizers (Muon, Apollo, AdamW, Adafactor, SinkGD, SGD, …) on the SmolLM corpus. Headline: **Muon wins at small batch** (eval loss 2.6778 vs AdamW 2.7392), with `beta2` scaling becoming critical at large batch.
+
+- **[Peak-memory ablation on a 1.6 B model](https://github.com/jdinalt/forgather/tree/main/examples/tiny_experiments/peak_memory)** — 9-way systematic ablation of memory-optimisation techniques. **81 % peak-memory reduction at ~2.7× throughput.** Pareto-frontier plots included.
+
+- **[Pretraining at 162 M from scratch](https://github.com/jdinalt/forgather/tree/main/examples/pretrain/small-llm)** — Llama trained on the SmolLM corpus, ten production-ready configs covering 1× and 10× Chinchilla budgets, AdamW / Adafactor / bf16 variants, plus a "Canon-A" custom architecture variant.
+
+- **[Multi-GPU 7B finetuning](https://github.com/jdinalt/forgather/tree/main/examples/finetune/samantha)** — Mistral-7B and Llama-3.2-1B on the Samantha conversational dataset across every trainer backend in the library. ~8.9 K tokens/sec on 4× RTX 4090 pipeline parallel.
+
+## Getting started
+
+```bash
+git clone https://github.com/jdinalt/forgather.git
+cd forgather
+docker/build.sh
+docker/run.sh
+
+# Inside the container:
+forgather server                     # web UI
+# or
+cd examples/tutorials/tiny_llama
+forgather -t v2.yaml train           # 5M-param Llama in ~10 minutes
+```
+
+The [Tiny Llama tutorial](https://github.com/jdinalt/forgather/tree/main/examples/tutorials/tiny_llama) walks through the full train → monitor → control → eval → inference → export flow. Full documentation lives at [forgather.readthedocs.io](https://forgather.readthedocs.io/en/latest/).
+
+## Project status
+
+Active development since 2023. Used by the author for ongoing ML research; APIs are stable enough that the documentation lags behind the code rather than vice versa. Forgather is solo-maintained — feedback, issues, and pull requests are welcome.
 
-*Alpha software seeking alpha testers. Help us build the future of accessible AI training.*
+[GitHub repository →](https://github.com/jdinalt/forgather){: .btn .btn-primary}
+[Documentation →](https://forgather.readthedocs.io/en/latest/){: .btn .btn-outline}
+[Discussions →](https://github.com/jdinalt/forgather/discussions){: .btn .btn-outline}