White Circle releases Halo 1.0, open-source training framework claiming 2.8x throughput on B300

White Circle has shipped version 1.0 of Halo, an open-source training framework that runs Hugging Face models without breaking their native format. The company reports up to 2.8 times the throughput of stock TRL on eight B300 accelerators. The code is on GitHub; Docker images pull anonymously from a public ECR with no account or registration required.

Architecture: no model rewrite

Halo's core design choice is leaving the model alone. Trainers inherit from the Hugging Face or TRL Trainer, checkpoints remain standard SafeTensors, and `from_pretrained` continues to work unchanged. Adding a new model family takes, by the company's count, fewer than 140 lines of integration code. Parallelism wraps existing blocks: expert parallelism wraps MoE blocks, context parallelism wraps attention, and tensor and expert-tensor parallelism place weights in-place — no separate distributed implementation of the architecture.

Distributed engine: pure PyTorch, DeepEP for expert communication

The distributed stack builds on PyTorch primitives — FSDP2, DTensor, DeviceMesh — with DeepEP handling all-to-all for expert parallelism. EP, CP, TP and ETP are independently configurable and compose across GPUs and nodes. Every training method (pre-training, SFT, preference, distillation, RL) shares the same parallelism and checkpointing infrastructure, so a new method does not need its own distributed implementation.

Performance: what the numbers say in practice

On 8×B300 the company reports roughly 2.8× training throughput versus stock TRL. When both sides run ZeRO-3, Halo delivers 2.7× throughput at 25% less peak memory. The stack bundles DeepEP V2, FlashAttention-4, Liger, grouped GEMM, padding-free packing and the AdamWBF16 optimizer, with implementations and fallbacks for Blackwell, Hopper and older GPUs. The figures are vendor-reported; no independent benchmarks or runs on specific models for comparison have been published.

Async RL: no Megatron, no veRL

The RL path runs asynchronously with a clean separation: training in regular Transformers, multi-threaded rollouts against a vLLM or SGLang server running as Ray actors, with a prefetch queue that hides training latency. Updated weights are pushed to the inference server over native NCCL. There is no Megatron backend and no veRL dependency; the parallelism and checkpointing stack stays identical to the training side.

Docker and distribution: separate images per architecture

Halo ships as two distinct Docker images: `blackwell` for B200/B300 (FA4 + FA2 + DeepEP) and `hopper` for H100/H200 (FA2 + FA3 + DeepEP). Versioned tags such as `:blackwell-1.0.0` pin the release; there is no `latest` tag because the images are architecture-specific. Inference images for RL (`:vllm-0.26.0`, `:sglang-0.5.17`) are published alongside. Local builds are available via `make build-blackwell` or `build-hopper` with no host Python environment required. Launch is through `halo launch` with a YAML config, scaling from LoRA on a single GPU to EP across eight GPUs via torchrun.