Hugging Face Spaces: The Complete Guide to AI Demos and Apps

What Are Hugging Face Spaces?

Hugging Face Spaces is a hosting platform for machine learning applications. It sits alongside the two pillars you already know from the Hugging Face ecosystem — Models and Datasets — and completes the triad: you publish your data, you publish your trained model, and then you publish a live demo that lets anyone try it in their browser.

That's the simple version. The reality is more interesting. Spaces has evolved from a basic demo hosting service into a full-stack application platform with GPU hardware tiers, containerized deployments, dynamic GPU allocation, and an integrated AI app directory that millions of developers browse every month.

Think of it as the closest thing to "Heroku for ML" that exists today — except it's free to start, deeply integrated with the Hugging Face Hub, and purpose-built for AI workloads rather than general-purpose web apps.

Why Spaces Matters

The AI landscape in 2026 is defined by a fundamental tension: models are getting more powerful, but the barrier to actually using them is getting higher. Training a model requires GPU clusters. Running inference at scale requires infrastructure. And demonstrating that your model works requires a user interface.

Spaces collapses all three barriers into one platform. You don't need to provision a server, configure a web framework, or deploy a frontend. You write a few lines of Python, push your code to Hugging Face, and your demo is live at huggingface.co/spaces/yourusername/your-app within minutes.

For researchers, this is transformative. A published model card tells people what your model does. A published Space shows them. The difference between telling and showing is the difference between a paper that gets cited and a model that gets used.

The Three SDKs

When you create a Space, you choose one of three SDKs. Each targets a different use case and developer workflow.

Note: Streamlit was previously a built-in SDK option, but Hugging Face deprecated it in favor of Docker. If you want to deploy a Streamlit app, you use the Docker SDK with the Streamlit template.

Hardware Tiers

Spaces isn't just a hosting platform — it's a compute platform. Hugging Face provides several hardware tiers, from free CPU to dedicated GPUs:

Tier	Hardware	Cost	Best For
Free CPU	Shared CPU	Free	Lightweight demos, API wrappers, static content
ZeroGPU	T4 GPU (serverless)	Free (limited compute hours)	GPU inference demos, Gradio-only
CPU Basic	Dedicated CPU	~$0.06/hr	Reliable CPU demos, non-GPU workloads
T4 GPU	NVIDIA T4 (16GB)	~$0.40/hr	Standard GPU inference, fine-tuned models
A10G GPU	NVIDIA A10G (24GB)	~$1.27/hr	Larger models, image generation, batch inference
A100 GPU	NVIDIA A100 (40GB)	~$2.92/hr	Large language models, training demos, heavy workloads

The ZeroGPU tier is particularly worth calling out. It provides serverless GPU access — your Space spins up a T4 GPU when someone interacts with it, and shuts down when idle. You only pay for active compute time, and free-tier users get a generous allocation. It's the closest thing to "free GPU hosting" that exists at scale.

What People Build on Spaces

With over 600,000 public Spaces, the variety is staggering. Here are categories and examples that illustrate the platform's range:

Our Use Case: IconShop SVG Generator

This brings us back to our own work. We've been training an SVG icon generation model based on the IconShop paper by Wu et al. (2023). As we documented in our previous posts, we trained a 16-layer transformer decoder on the FIGR-SVG dataset over two days of GPU compute, producing a model that generates vector icons from text prompts.

We published the model weights to Hugging Face Hub. But publishing weights is only half the story. Anyone can download a checkpoint file — far fewer people will actually run inference on it. The friction of setting up the environment, loading the model, and writing inference code is a significant barrier.

A Space eliminates that barrier entirely. Here's what our IconShop demo Space would look like:

The demo would be straightforward: a Gradio interface with a text input for the prompt, controls for temperature and top-p sampling, and an SVG output display that renders the generated icon in real time. Users could generate multiple variants, download the SVG files, and share their results.

Here's the rough architecture:

iconshop-space/
├── app.py              # Gradio interface
├── requirements.txt    # Dependencies (torch, gradio, transformers)
├── model/              # Model weights (loaded from HF Hub)
│   ├── checkpoint.pth
│   └── config.json
├── inference.py        # Model loading and generation logic
└── README.md           # Space description

The Gradio app itself is minimal — perhaps 50 lines of Python:

import gradio as gr
from inference import load_model, generate_icon

model = load_model("thinksmart/iconshop-svg-generator")

def generate(prompt, temperature, top_p):
    svg = generate_icon(model, prompt, temperature=temperature, top_p=top_p)
    return svg

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", placeholder="e.g., bottle, star, clock"),
        gr.Slider(0.1, 1.0, value=0.4, label="Temperature"),
        gr.Slider(0.1, 1.0, value=0.5, label="Top-p"),
    ],
    outputs=gr.HTML(label="Generated SVG Icon"),
    title="IconShop SVG Generator",
    description="Generate vector icons from text prompts using our trained transformer model."
)

demo.launch()

That's it. Deploy this to a ZeroGPU Space, and anyone in the world can try our model without installing anything. No API keys, no setup, no dependencies. They go to a URL, type a prompt, and see an icon appear.

Why does this matter for us as AI researchers? Three reasons:

1. Credibility. A live demo proves the model works. A model card claims it does — a Space demonstrates it. There's a fundamental difference between saying "our model generates icons" and letting someone generate one themselves.
2. Discovery. Spaces are indexed by Hugging Face's AI app directory. People browsing for "SVG" or "icon generation" will find our demo. That's organic traffic we wouldn't get from a model page alone.
3. Feedback loop. Every interaction with the Space is data. We can see which prompts produce good results, which ones fail, and use that to improve the model. A Space turns passive viewers into active testers.

Spaces as a Research Tool

Beyond demos, Spaces serve a deeper purpose in the AI research workflow. They're the bridge between academic research and practical utility. Here's how they fit into the research lifecycle:

ZeroGPU: The Game Changer

One of the most significant recent additions to Spaces is ZeroGPU — Hugging Face's serverless GPU tier. Here's why it matters:

Traditional GPU hosting charges you by the hour, whether your Space is being used or not. If you deploy a demo on a T4 GPU and nobody visits it for three days, you've still paid for 72 hours of compute. ZeroGPU flips this model: the GPU is provisioned on-demand when someone interacts with your Space, and deprovisioned when idle. You only pay for active compute time.

For research demos, this is ideal. Most Spaces have bursty traffic — a spike when you share a link, then quiet periods. ZeroGPU matches that usage pattern perfectly. Free-tier users get a generous allocation of serverless GPU hours, which is more than enough for a research demo.

The catch: ZeroGPU currently works only with Gradio Spaces. If you need Docker or static HTML with GPU access, you'll need to use a paid hardware tier. But for most ML demos, Gradio is sufficient.

Best Practices for Building Spaces

Beyond Demos: Spaces as Production Apps

While Spaces started as a demo platform, the line between demo and production is blurring. Several companies now use Spaces as the frontend for their AI products — not because it's the most scalable architecture, but because it's the fastest way to get to market.

The workflow looks like this: build a prototype on Spaces → validate demand → migrate to production infrastructure. Spaces becomes your MVP platform. For AI startups, this is a significant advantage — you can test a product idea in a weekend instead of a month.

Hugging Face acknowledges this use case. Their PRO and Enterprise tiers offer dedicated hardware, custom domains, and higher resource limits specifically for teams running production workloads on Spaces.

The Bottom Line

Hugging Face Spaces has become the default platform for ML demos, and for good reason. It removes the infrastructure friction that used to separate a trained model from a public demo. You write Python, you push code, your demo is live.

For us, the next step is clear. We've trained our IconShop SVG generator. We've published the weights. Now we need to build the Space — a live, interactive demo that lets anyone generate vector icons from text prompts. It's not just a marketing move. It's a research move. A Space turns our model from a static artifact into a living, breathing demonstration of what AI research looks like in practice.

The best AI researchers don't just train models. They build tools that let other people experience those models. Spaces is the tool that makes that possible.

References

1. Hugging Face Spaces — The AI App Directory
2. Spaces Overview — Official documentation
3. Gradio Spaces — Building demos with Gradio
4. Docker Spaces — Custom container deployments
5. ZeroGPU — Serverless GPU allocation for Spaces
6. Featured Spaces — Curated weekly selections
7. "IconShop: Text-Guided Vector Icon Synthesis with Autoregressive Transformers" — Wu, Su, Ma, Liao (2023)
8. Training Our First SVG Icon Generation Model — Our hands-on IconShop training post
9. How to Publish Your First Model to Hugging Face — Publishing our IconShop model to the Hub