Open Gauss Documentation

ASCII Video is a skill designed to teach agents how to build single-file Python renderers that convert various inputs (video, audio, images, text, or mathematical functions) into colored ASCII character video.

Unlike terminal-based ASCII, this produces actual video files (MP4, GIF, or PNG sequences) by computing frames as grids of colored characters composited onto pixel canvases using pre-rasterized font bitmaps. It features a full pipeline including grid systems, effect libraries, shader chains, and audio analysis, all running without a GPU.

The pytorch-fsdp skill provides expert guidance for implementing Fully Sharded Data Parallel (FSDP) training using PyTorch. It covers advanced distributed training techniques including parameter sharding, mixed precision training, CPU offloading, and the FSDP2 API.

Use this skill when you need to:

• Implement or debug PyTorch FSDP solutions.
• Learn best practices for large-scale distributed training.
• Configure FSDP features like sharding strategies or mixed precision.
• Work with FSDP2 APIs.

Gauss is a focused Lean workflow workspace designed around managed CLI-agent sessions. Instead of a general agent platform, it provides a narrow, guided experience for Lean 4 development through a specific session lifecycle:

1. Start the gauss CLI.
2. Select a specific workflow using a slash command: /prove, /draft, /autoprove, /formalize, or /autoformalize.
3. Enter the managed Lean session associated with that workflow.
4. Once the child session exits, Gauss restores the original session state.

This model allows for specialized environments (like autonomous proving or interactive formalization) while maintaining a consistent user session.

Gauss Agent is a modular orchestration engine composed of several specialized subsystems. It has evolved from a simple chat loop into a complex system supporting multiple API modes, auxiliary model routing, ACP editor integration, and RL (Reinforcement Learning) environment infrastructure.

Key design themes include:

• Prompt Stability: Ensuring consistent prompt behavior.
• Observable Tooling: Tool execution must be observable and interruptible.
• Resilient Persistence: Session state must survive long-running operations.
• Core/Frontend Separation: Platform frontends (CLI, Gateway, ACP) share a single agent core.
• Loose Coupling: Optional subsystems are designed to remain decoupled from the core.

Unsloth is an open-source framework designed for efficient LLM fine-tuning and reinforcement learning (RL). It provides optimized workflows for training various model architectures, including Llama, Mistral, Gemma, and specialized reasoning models.

Key capabilities include:

• Fine-tuning: Support for LoRA, QLoRA, and continued pretraining.
• Reinforcement Learning: Support for GRPO, DPO, ORPO, and KTO.
• Quantization: Advanced Dynamic GGUF quants and Quantization-Aware Training (QAT).
• Multimodal Support: Fine-tuning for Vision/multimodal models (VLM).
• Deployment: Exporting models to GGUF (for Ollama, llama.cpp), vLLM, and SGLang.

Unsloth provides a catalog of models on Hugging Face available in several formats:

• GGUF: Optimized for running models in tools like Ollama, Open WebUI, and llama.cpp.
• 4-bit (Instruct): Provided as safetensors, these are suitable for either inference or fine-tuning.
• 16-bit: Full precision models.
• Dynamic GGUFs: Specialized GGUF versions available via Unsloth Dynamic 2.0.

The catalog includes support for major model families such as DeepSeek, Llama, Gemma, Qwen, Mistral, and Phi.

Group Relative Policy Optimization (GRPO) is a reinforcement learning algorithm used for fine-tuning language models. Unlike PPO, GRPO does not require a separate reward model; instead, it generates a group of completions for each prompt (typically 4-16) and compares their rewards within that group to update the policy.

Use GRPO when you need to:

• Enforce specific output formats (XML, JSON, structured reasoning).
• Teach verifiable tasks with objective metrics (math, coding, fact-checking).
• Improve reasoning via chain-of-thought rewards.
• Align models to domain-specific behaviors without preference pairs.
• Optimize for multiple objectives (format + correctness + style).

Do NOT use GRPO for:

• Simple supervised fine-tuning (use SFT).
• Tasks without clear reward signals.
• When you already have high-quality preference pairs (use DPO/PPO).