Instructions to use Rohanify/Indensa-Coder-FrontEnd with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Rohanify/Indensa-Coder-FrontEnd with Transformers:

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

pipe = pipeline("text-generation", model="Rohanify/Indensa-Coder-FrontEnd")

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("Rohanify/Indensa-Coder-FrontEnd", dtype="auto")

llama-cpp-python

How to use Rohanify/Indensa-Coder-FrontEnd with llama-cpp-python:

# !pip install llama-cpp-python

from llama_cpp import Llama

llm = Llama.from_pretrained(
	repo_id="Rohanify/Indensa-Coder-FrontEnd",
	filename="Indensa-Coder-FrontEnd-34M-F16.gguf",
)

output = llm(
	"Once upon a time,",
	max_tokens=512,
	echo=True
)
print(output)

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use Rohanify/Indensa-Coder-FrontEnd with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf Rohanify/Indensa-Coder-FrontEnd:F16
# Run inference directly in the terminal:
llama cli -hf Rohanify/Indensa-Coder-FrontEnd:F16

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf Rohanify/Indensa-Coder-FrontEnd:F16
# Run inference directly in the terminal:
llama cli -hf Rohanify/Indensa-Coder-FrontEnd:F16

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf Rohanify/Indensa-Coder-FrontEnd:F16
# Run inference directly in the terminal:
./llama-cli -hf Rohanify/Indensa-Coder-FrontEnd:F16

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf Rohanify/Indensa-Coder-FrontEnd:F16
# Run inference directly in the terminal:
./build/bin/llama-cli -hf Rohanify/Indensa-Coder-FrontEnd:F16

Use Docker

docker model run hf.co/Rohanify/Indensa-Coder-FrontEnd:F16

LM Studio
Jan

vLLM

How to use Rohanify/Indensa-Coder-FrontEnd with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Rohanify/Indensa-Coder-FrontEnd"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Rohanify/Indensa-Coder-FrontEnd",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/Rohanify/Indensa-Coder-FrontEnd:F16

SGLang

How to use Rohanify/Indensa-Coder-FrontEnd 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 "Rohanify/Indensa-Coder-FrontEnd" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Rohanify/Indensa-Coder-FrontEnd",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

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 "Rohanify/Indensa-Coder-FrontEnd" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Rohanify/Indensa-Coder-FrontEnd",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Ollama
How to use Rohanify/Indensa-Coder-FrontEnd with Ollama:
```
ollama run hf.co/Rohanify/Indensa-Coder-FrontEnd:F16
```

Unsloth Studio

How to use Rohanify/Indensa-Coder-FrontEnd with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for Rohanify/Indensa-Coder-FrontEnd to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for Rohanify/Indensa-Coder-FrontEnd to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for Rohanify/Indensa-Coder-FrontEnd to start chatting

Atomic Chat new
Docker Model Runner
How to use Rohanify/Indensa-Coder-FrontEnd with Docker Model Runner:
```
docker model run hf.co/Rohanify/Indensa-Coder-FrontEnd:F16
```

Lemonade

How to use Rohanify/Indensa-Coder-FrontEnd with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull Rohanify/Indensa-Coder-FrontEnd:F16

Run and chat with the model

lemonade run user.Indensa-Coder-FrontEnd-F16

List all available models

lemonade list

Rohanify commited on 13 days ago

Commit

0de0f67

verified ·

1 Parent(s): 1ca1987

Update README.md

Browse files

Files changed (1) hide show

README.md +170 -0

README.md CHANGED Viewed

@@ -1,3 +1,173 @@
 ---
 license: mit
 ---

 ---
 license: mit
+language:
+- en
+tags:
+- html
+- css
+- tailwind
+- code-generation
+- from-scratch
+- small-model
+- text-generation
+library_name: transformers
+pipeline_tag: text-generation
 ---
+# Indensa-Coder-FrontEnd
+`This is a V1 model. Can be used. V2 is coming soon!`
+A 33M parameter decoder-only transformer that takes a text prompt and spits out a bite-sized HTML + Tailwind CSS block. Trained from scratch on my desk in 6 minutes.
+This is not a SOTA model. It's not trying to be. It's a small honest model that learned the shape of web components from a curated dataset, and now it can make new ones.
+If you wanted GPT-4-level web design, this isn't it. If you wanted a tiny model you can actually run anywhere, including on Ollama with a fast prompt-to-HTML use case, you're in the right place.
+|---|---|
+| ![](example.png) | ![](example1.png) |
+## What it does
+You give it something like:
+```
+PROMPT: a hero section for a SaaS landing page
+HTML:
+```
+And it continues with a real HTML document using Tailwind classes. The output is bite-sized (≤512 tokens by design), so think landing page sections, pricing cards, contact forms, navbars — not entire 10-page websites.
+## Sample output
+Prompt: *"a publishing house landing page"*
+```html
+<html>
+<link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
+<body class="bg-gray-100">
+  <header class="bg-white p-4">
+    <h1 class="text-2xl font-bold">Publishing House</h1>
+  </header>
+  <section class="p-4">
+    <h2 class="text-xl font-bold">Welcome to our Publishing House</h2>
+    <p>We are a leading publisher of high-quality books...</p>
+  </section>
+  ...
+  <footer class="bg-white p-4">
+    <p>© 2022 Publishing House. All rights reserved.</p>
+  </footer>
+</body>
+</html>
+```
+That output was checked manually against the training set — no 100% match exists in training data. So it's actually generating, not parroting.
+## The honest details
+| Thing | Value |
+|---|---|
+| Parameters | 33.6M |
+| Architecture | Decoder-only transformer |
+| Layers | 8 |
+| d_model | 512 |
+| Heads | 8 (head_dim 64) |
+| FFN dim | 2048 |
+| Block size | 1024 |
+| Tokenizer | Custom ByteLevel BPE, vocab 16,000 |
+| Training data | ~50k samples from HuggingFaceM4/WebSight v0.2 (Tailwind) |
+| Training tokens | 10.17M (8 epochs = ~81M effective) |
+| Best val loss | 0.4772 |
+| Training time | 7.4 minutes |
+| Hardware | RTX 5080 16GB |
+| Precision | bf16 mixed |
+## Why custom BPE
+GPT-2's BPE was trained on web prose, not code. It splits stuff like `text-3xl` into 4 tokens and `bg-gradient-to-r` into 7 tokens. My custom 16k BPE trained on WebSight compresses these to 1-2 tokens because Tailwind patterns are everywhere in the corpus.
+Net result: roughly 1.5-2× better compression on the same content, which means more useful content fits inside the 512-token window.
+## Why 33M params
+I did the math. Chinchilla-optimal for 10M tokens is around 500k params, which is too tiny to learn anything interesting. For structured code with high pattern repetition, 5-10× Chinchilla is the empirical sweet spot. 33M lands in that range. Big enough to learn HTML structure, small enough to not just memorize 10M tokens at 8 epochs.
+The train/val gap stayed around 0.1 nats throughout training. That means generalization, not memorization. Confirmed by manually searching the training data for the sample output above — no exact match exists.
+## How to use it (Python)
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+tokenizer = AutoTokenizer.from_pretrained("Rohanify/Indensa-Coder-FrontEnd")
+model = AutoModelForCausalLM.from_pretrained("Rohanify/Indensa-Coder-FrontEnd").to("cuda")
+prompt = "PROMPT: a pricing card with three tiers\nHTML:\n"
+input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to("cuda")
+output = model.generate(
+    input_ids,
+    max_new_tokens=400,
+    temperature=0.8,
+    top_k=50,
+    do_sample=True,
+)
+print(tokenizer.decode(output[0]))
+```
+Then prompt it the same way. It's small enough to run anywhere.
+## Things it's good at
+- Bite-sized HTML blocks (landing page sections, components)
+- Tailwind class usage that mostly looks right
+- Common patterns: cards, headers, footers, forms, navbars, hero sections
+- Producing valid HTML that opens in a browser without errors most of the time
+- Being tiny and fast
+## Things it's NOT good at
+- Full multi-page websites (not what it was trained for)
+- Modern Tailwind v3+ utility classes that didn't exist in WebSight v0.2 (the dataset uses Tailwind 2.2.19)
+- Highly specific design requests with lots of constraints
+- Anything outside the WebSight distribution (think generic-looking business websites)
+- Replacing a real designer or v0.dev
+It's a 33M model trained for 6 minutes. Manage your expectations and it'll surprise you. Expect SOTA and you'll be disappointed.
+## Training data
+[HuggingFaceM4/WebSight v0.2](https://huggingface.co/datasets/HuggingFaceM4/WebSight) — synthetic HTML+Tailwind pairs generated by Deepseek-Coder-33B from Mistral-7B prompts. I used the first 50k rows, filtered to samples ≤512 tokens after tokenization, and threw away the screenshots since this is a pure text task.
+## Roadmap
+- Train v2 on Ollama-generated prompts and components — more diversity, less synthetic feel
+- More training data (the 50k cap was based on what I could download in a session)
+- Maybe a 128M version if there's interest
+- Modern Tailwind v3+ support
+## License
+MIT. Use it for whatever. Attribution appreciated but not required.
+## Author
+Made by Rohan ([Rohanify on HuggingFace](https://huggingface.co/Rohanify)). Also on YouTube as ElectroPlayin where I make AI tutorials and weird projects.
+Built in a single session on a home PC with help from Claude (Anthropic). The architecture decisions, dataset curation, debugging cycles, frustration, and final ship are all mine. The math checks and code scaffolding came from a long conversation.
+If you find this useful or just funny, drop a like on HF or come say hi. If you train a bigger version, I'd love to see it.
+## Citation
+If you use this for anything serious (you probably shouldn't, it's a hobby model, but):
+```
+@misc{indensa2026,
+  author = {Rohan},
+  title = {Indensa-Coder-FrontEnd: A 33M Parameter Prompt-to-HTML Model},
+  year = {2026},
+  publisher = {HuggingFace},
+  url = {https://huggingface.co/Rohanify/Indensa-Coder-FrontEnd}
+}
+```