ai-lqm/ai-localqmod-js-slm

AI LocalQmod — JS-family Code SLMs (GGUF)

Ultra-small, single-purpose code-generation models — as light as 17.4 MB.

Trained from scratch by AI LocalQmod, LLC for JavaScript-ecosystem code generation. Roughly 1/200th the size of a general-purpose coding model (~4.4 GB), so they download in seconds, load instantly, and barely touch your memory.

Plain llama.cpp GGUF files — usable with any GGUF-compatible runtime.

File	Built for	Vocab	Params	Size
react-slm-Q4_K_M-chat.gguf	React	1,598	26.5M	17.4 MB
jsts-slm-Q4_K_M-chat.gguf	JavaScript + TypeScript	3,094	27.3M	18.4 MB
node-slm-Q4_K_M-chat.gguf	Node.js	9,697	30.7M	21.0 MB
js-loops-slm-Q4_K_M-chat.gguf	JavaScript (loops & arrays)	10,000	30.8M	21.4 MB

Specifications

Architecture	llama — 8 blocks, 512 hidden, 1408 FFN, 8 heads (MHA)
Context length	128 tokens
Tokenizer	BPE (GPT-2 style), trained from scratch per model
Quantization	Q4_K_M (token_embd at Q6_K, tied embeddings)
Prompt language	Japanese
Format	GGUF v3 — llama.cpp, llama-cpp-python, LM Studio, Ollama
License	MIT

---

What they are for

Each model is purpose-built for one job: generating a single small function in its target language — a loop, an array operation, a React component, a Node.js file handler. A from-scratch tokenizer tuned to that language's syntax is what keeps them this small and this fast.

They are components, not assistants — sized for one function at a time, and fast enough that a laptop CPU returns one in milliseconds. Planning, assembly and verification belong to the tool that calls them, which is exactly what AI-App Builder does.

---

How to prompt them — read this first

These models use one fixed prompt template. Follow it exactly and they do what they were built to do. This is the one thing to get right.

しつもん: <request, in Japanese>
こたえ: ```js

The prompt must end with the opening code fence. Stop generation at the closing fence. Requests are in Japanese — the training corpus is Japanese instruction → JS-family code. English prompts do not work.

llama-cpp-python

from llama_cpp import Llama

llm = Llama(model_path="js-loops-slm-Q4_K_M-chat.gguf", n_ctx=128)
out = llm("しつもん: 配列の合計を求める関数\nこたえ: ```js\n",
          max_tokens=80, temperature=0.0, stop=["```"])
print(out["choices"][0]["text"])

function evaluate(numbers) {
  let sum = 0;
  for (let i = 0; i < numbers.length; i++) {
    sum += numbers[i];
  }
  return sum;
}

llama.cpp

./llama-cli -m js-loops-slm-Q4_K_M-chat.gguf -n 80 --temp 0 \
  -p 'しつもん: 配列の合計を求める関数
こたえ: ```js
'

Verified example prompts

Each of these was run at temperature=0.0 and produced correct, valid code. Note that react-slm also uses the ```js fence, not ```jsx.

Model	Fence	Example prompt	Produces
js-loops-slm	```js	配列の合計を求める関数	correct for loop summing an array
js-loops-slm	```js	配列の最大値を返す関数	correct max loop starting at i = 1
js-loops-slm	```js	偶数だけ数える関数	correct % 2 === 0 counter
react-slm	```js	ボタンのコンポーネント	a useState button component
node-slm	```js	ディレクトリを作る	mkdir from fs/promises, recursive
jsts-slm	```ts	インターフェースを定義する	a TypeScript interface

Which model to use

Model	Built for
js-loops-slm	for loops and array traversal — sums, min/max, counting
react-slm	React function components with hooks
node-slm	Node.js file-system and server code
jsts-slm	TypeScript type and interface definitions

Each one is trained on its own narrow corpus with its own tokenizer. Pick the model that matches the job.

Coming end of September 2026: a general JavaScript model. Until it lands, js-loops-slm is the one to use for plain JavaScript.

With AI-App Builder (one click)

AI-App Builder is our macOS app. It runs a planner model that breaks a request into parts, sends each part to the SLM above, verifies the returned code structurally, and assembles a working app.

Open the ⬇️ Model DL tab — these four models are listed at the top. Click one and the download fields fill in automatically. Everything runs on your own Mac; nothing you write is sent to our servers.

US$9.99/month, first 7 days free.

---

Also from AI LocalQmod, LLC

AI Era Design Docs

A prompt is a poor way to brief an AI on anything larger than a snippet. A written spec works far better — but writing one, keeping it current, and maintaining a second copy formatted for the AI is exactly the work nobody wants to do.

AI Era Design Docs is a macOS app that builds the spec from a form. Pick a block, fill it in, and watch the finished document render beside you as you type. Then export the same content three ways:

Export	For
HTML	People. One self-contained file, diagrams included — opens anywhere, no network needed
Markdown	Your AI. Diagrams come out as mermaid code blocks, so nodes and connections stay machine-readable
PDF	Reading and printing

The part that matters: it reads its own output back in. Re-import the exported HTML or the Markdown and carry on editing from where you left off. Most tools only ever export — when the spec changes, you start again from an empty form.

Diagrams need no mermaid syntax: add nodes, pick colours, connect them with arrows. Tables, callouts, ordered lists and file headers are all fields — there is nothing to memorise. Everything runs on your own Mac; nothing you type leaves it.

US$2.99/month, first 7 days free.

---

Why we give these away

The models are MIT-licensed and free because they are only half the answer. A 17 MB model that writes one correct function is genuinely useful, but turning that into a working application takes orchestration, verification, and repair. AI-App Builder delivers all three.

If these models are useful to you on their own, take them. If you want the rest, it is AI-App Builder.

About AI LocalQmod, LLC

AI LocalQmod, LLC builds local-first, privacy-respecting AI tools. Everything we ship runs on your own machine.

Company	ai-localqmod.com
AI-App Builder	ai-localqmod.com/ai-app-builder
AI Era Design Docs	ai-localqmod.com/ai-virgo
Support	support@ai-localqmod.com

License

MIT — free to use, modify, and redistribute, including commercially.