Instructions to use Situus/STARK-WEB-12B-v1.7 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Situus/STARK-WEB-12B-v1.7 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Situus/STARK-WEB-12B-v1.7")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("Situus/STARK-WEB-12B-v1.7")
model = AutoModelForMultimodalLM.from_pretrained("Situus/STARK-WEB-12B-v1.7")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Situus/STARK-WEB-12B-v1.7 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Situus/STARK-WEB-12B-v1.7"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Situus/STARK-WEB-12B-v1.7",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Situus/STARK-WEB-12B-v1.7

SGLang

How to use Situus/STARK-WEB-12B-v1.7 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Situus/STARK-WEB-12B-v1.7" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Situus/STARK-WEB-12B-v1.7",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Situus/STARK-WEB-12B-v1.7" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Situus/STARK-WEB-12B-v1.7",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use Situus/STARK-WEB-12B-v1.7 with Docker Model Runner:
```
docker model run hf.co/Situus/STARK-WEB-12B-v1.7
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

⚡ STARK-WEB-12B v1.7

The Premium Open-Source AI UI/UX Designer & Frontend Engineer

⚡ Looking for local execution? The repository you are currently viewing contains the unquantized raw Safetensors weights. If you are looking to run this model locally via LM Studio, llama.cpp, or Ollama, Click here to visit the quantized GGUF repository (STARK-WEB-12B-v1.7-gguf).

🔍 Overview & Methodology

STARK-WEB-12B v1.7 is an advanced, highly specialized model fine-tuned on the Gemma 4 12B architecture. Engineered to act as a premium UI/UX designer and frontend developer, this model bridges the gap between raw code generation and artistic web design.

The training methodology behind STARK-WEB focuses on high-quality, synthetic web generation tasks derived from state-of-the-art models. The current iteration was fine-tuned on a heavily curated dataset comprising approximately 16 million tokens. This vast expansion from previous versions has drastically reduced overfitting and improved logical coherence in complex tasks.

Unlike standard coding assistants that output plain layouts, STARK-WEB-12B relies on a custom 9-step Chain-of-Thought (CoT) reasoning process. This explicit thinking phase allows the model to conceptualize physics, map custom color variables, and plan grid architectures before writing any code. The result is visually breathtaking interfaces featuring fluid transitions, advanced HSL color dynamics, glassmorphism, and highly robust logic.

📊 Technical Specifications

Feature	Technical Details
🧠 Base Architecture	Gemma 4 12B (via `google/gemma-4-12b-it`)
📈 Dataset Volume	~16 Million Tokens (highly-complex refined web app & game logic)
🎯 Target Capabilities	Single-file dashboards, canvas games, responsive tools, fluid animations
💾 Fine-Tuning Setup	LoRA (r=64, alpha=128) on RTX 5060 Ti 16GB
🌍 Language Support	~90% English, ~10% Polish (fully bilingual comprehension)

🛡️ Structured Chain-of-Thought (CoT) Workflow

To resolve logical hallucinations and infinite loops, STARK-WEB-12B v1.7 is constrained to reason through a strict 9-step algorithmic roadmap. This enforces cognitive staging, pushing the model to outline logic before generating syntax.

⚙️ The 9 Reasoning Stages

Understand the Goal: Analyze request scope, interface goals, and overall user flow.
Inputs: Map variables, event triggers, user inputs, and storage needs.
Output: Establish DOM results, target screens, and state resets.
Identify Key Constraints & Technologies: Lock down browser APIs, grid constraints, and physics bounds.
Design the HTML Structure: Plan semantic tag hierarchies and container distributions.
Design the CSS: Map custom color variables (HSL), responsive layouts, transitions, and glow shadows.
Design the JavaScript: Lay out event handlers, physics intervals, and rendering cycles.
Refinement & Implementation: Synthesize code cleanups, performance tweaks, and responsiveness.
Final Review: Final validation checklist (errors, edge-case safety, formatting).

The thinking process executes exactly between the <|channel>thought and <channel|> tags.

⚠️ Limitations & Client Integration

🛠️ Known Limitations & Bug Fixing

While version 1.7 represents a massive leap forward, it unfortunately may still make logical errors or typos that can break code rendering. Generating complex HTML, CSS, and JS simultaneously in a single shot remains a significant challenge for 12B parameter models.

If your application renders as a blank screen or has broken handlers, simply feed the code back into the model with the prompt: "Review the generated code above. Identify any rendering or logical errors, and output a corrected version."

❌ IDE & OpenCode Compatibility

Please note that this version (v1.7) is heavily specialized for single-shot, web-based prototyping and utilizes custom reasoning tags (<|channel>thought). It is currently NOT natively compatible with standard IDE plugins, AI assistants, or OpenCode ecosystems. These integrations often fail to properly parse or hide the custom thinking blocks, resulting in raw tag output in your editor.

🚀 How to Use (Transformers)

The model is published in the secure safetensors format. It uses the standard Gemma format (<|turn|>) and is designed to run with an empty system prompt.

💻 Click to expand Python Inference Snippet

from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Situus/STARK-WEB-12B-v1.7")
model = AutoModelForCausalLM.from_pretrained("Situus/STARK-WEB-12B-v1.7", device_map="auto", torch_dtype="auto")

messages = [
    {"role": "user", "content": "Write a fully functional Canvas snake game in a single HTML file."}
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(**inputs, max_new_tokens=4096, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=False))

🔮 Future Roadmap: STARK-WEB v2

While v1.7 sets a strong foundation for single-file web prototyping, we are already hard at work on STARK-WEB v2.

The upcoming generation will feature:

Full IDE & OpenCode Compatibility: Native support for seamless integration into your favorite code editors without reasoning tag leakage.
Wider Scope: Moving beyond single-file applications to support multi-file React, Vue, and Node.js architectures.
Advanced Graphics: Native training support for 3D games, Three.js, and WebGL experiences.

Stay tuned!

📜 Citation & License

This model is open-sourced under the Apache 2.0 license.

@misc{situus2026starkweb,
  author = {Situus},
  title = {STARK-WEB-12B v1.7: Optimizing Open Source Large Language Models for Structured Web Application Synthesis},
  year = {2026},
  publisher = {Hugging Face},
  journal = {Hugging Face Model Hub}
}

Downloads last month: 13

Safetensors

Model size

12B params

Tensor type

BF16

Model tree for Situus/STARK-WEB-12B-v1.7

Quantizations

3 models

Collection including Situus/STARK-WEB-12B-v1.7

STARK-WEB

Collection

4 items • Updated 2 days ago