0.6.5 · beta

A neural network you can see

zhele is a language and desktop environment for neural networks. Build a model from blocks, train it on your computer and find the cause of errors. In 0.6.1, resume from a selected snapshot, check the actual GGUF file and build a training portion from new JSONL examples you supply.

Download for Windows See 0.6 in action Telegram bot Windows 10/11 · free trial week · Python and PyTorch required
move along the strand

0.6.1: data preparation and training diagnostics

Published October 9. Each example identifies its language and format.

0.6.1: your examples without holdout leakage

Published October 9. 37 seconds, English speech and English captions.

A JSONL pool contains your inputs and targets. Preview excludes duplicates, held-out inputs and examples linked to a broken validator. The selected example goes into a separate training branch.

In this real CPU example, the guard passes but the target checks still fail. This is an experiment, not a promise of a fix.

Watch on YouTube

0.6.1: first experiment and diagnostics

52 seconds, complete Russian captions, no voice.

A 150-step check on one fixed batch shows its loss decreasing.

Held-out quality requires a separate evaluation. A single-batch metric does not promise a model fix.

Watch on Facebook
Release 09 Oct 2026 · 0.6.1

Three tasks in the working app

Windows demonstrations: live edits, training doctor and model inspection. These three clips were prepared for 0.6.0, with English captions and narration.

Edit a network during training

Preview which weights stay and which start from scratch. Apply the edit and continue from the same step. Branch from a saved snapshot.

Find why training is going wrong

The training doctor highlights dead blocks and weak gradients and suggests a fix. Compare training curves before and after on one chart.

Estimate memory before downloading weights

Enter a Hugging Face model name to inspect its architecture and estimate weight and KV-cache memory. An estimate is not a guarantee that it will run.

This example on YouTube

Your first experiment: change one block

Install zhele, get a trial key in the app and open an example. Start a small training run, change an activation and inspect the live-edit plan. If you get stuck, send support your steps and a screenshot.

Start with installation
Features

From a diagram to your own language model

The colour of each mark is the block's family on the scene: layers with weights, mixing, data, goal, functions.

Build

Layers with weights, attention, mixture of experts, convolutions, recurrent blocks. Ready templates of modern nets: Llama 3, Qwen3, Gemma 3, DeepSeek V3, gpt-oss, Mamba-2 and hybrids. Write your own block once and use it anywhere; the helper edits the program from a request in words (beta).

Train and understand why

On your own GPU or CPU: a live loss curve, your own data — text, images, sound, tables, graphs. The course «your own language model from scratch» — 15 lessons inside the window: every step says why, and after each action shows what changed in the net and what it means.

Understand and fix

Lenses show on the scene where the weights, compute, time, memory and usefulness are. The training doctor finds dead blocks, vanishing gradients and the first NaN, suggests a fix and shows before / after on one chart. Went to NaN — a plain-PyTorch repro.py lands next to the run and replays the failure in one command.

Bring in and take out

Import: Hugging Face weights, PyTorch code, ONNX from TensorFlow, Keras and JAX. Export: Hugging Face, GGUF for llama.cpp, ONNX with a numeric check. From Python — zhele.compile("model.zhele").

Change it live

Edit a net during training and review the live-edit plan: which weights carry over and which start afresh. Select a snapshot in history to start a separate branch with its weights, optimizer state and random generator state.

Check and compare

Define model checks and keep guards separate from training examples. Counters and filters help locate failures; a JSONL pool builds a portion from explicit new examples, excluding duplicates and held-out inputs. The actual GGUF report identifies its SHA256 and runtime, with coverage, verdict agreement and answer agreement shown separately. Incomplete verification stays incomplete.

The zhele language

Diagram and text are one program

The strand above and this text are the same net. Edit a block on the scene and the line changes; edit the line and the strand changes.

net:
    input tokens
    emb = embed(tokens)
    pos = positions(emb)
    floors = repeat "Floors" (x = pos, times 4):
        n1 = norm(x)
        att = attention(n1)
        r1 = x + att
        n2 = norm(r1)
        mlp = mlp(n2, hidden 512)
        r2 = r1 + mlp
        output out = r2
    nf = norm "Final norm"(floors)
    head = head(nf)
    output logits = head

train:
    budget: kind steps, value 600
    optimizer: kind AdamW, lr 0.003
Blocks. embed, norm, attention are blocks with weights. The compiler checks shapes before training and shows an error right where it is.
Repeat. repeat … times 4 is four identical floors in one bubble. On the scene it is a bulge with four bands.
Training. The train section is the budget, optimizer and schedule. The «Train» button compiles the text into real PyTorch code and runs it.
Code out. The «Code» tab shows this PyTorch in full: you can take it and run it without zhele.
The zhele window: a palette of blocks and templates on the left, the net drawn as a strand with bulges in the middle, a course step with its explanation and the net's numbers on the right
The zhele window: palette, the net inside the «Net» section, and on the right a course step with «Why» and the net's numbers.
Updates

What's new

The program updates itself: every 6 hours it checks for a new version, verifies the author's signature and installs it on the next start.

0.6.512.10.2026 — User data and interface hotfix
  • Automatic interface translation preserves user names, paths, code and model/helper replies. Installation docs and source-core boundaries are clearer. Native modules and activation rules are unchanged. The installer remains unsigned; Windows warnings may remain.
0.6.412.10.2026 — Activation hotfix
  • Damaged ZA1/ZA2 keys are classified correctly. Activation-page errors, including an initial saved-key error, are shown in Russian or English. Signing and entitlements are unchanged. The installer remains unsigned; Windows warnings may remain.
0.6.311.10.2026 — Activation hotfix
  • Damaged keys and issuer certificates, and invalid activation requests, are rejected without an internal error. An existing valid key stays unchanged. Activation and About messages are clearer in Russian and English. The installer remains unsigned; Windows warnings may remain.
0.6.211.10.2026 — Windows installation and startup hotfix
  • Russian or English installer with a readable agreement; CPython 3.12 x64 and required dependency checks. Fixed startup when the port is occupied and cleanup of owned processes on close or startup failure. The installer remains unsigned; Windows warnings may remain.
0.6.109.10.2026 — “Resume, check, export”
  • Resume from the selected snapshot. Restore weights, optimizer, EMA and random-number generator state, including dropout. Previewing a plan does not change the next training step's randomness; a missing required snapshot produces a clear error instead of silently restarting from scratch.
  • A new portion from a JSONL pool. Examples are linked to consistently failing checks, with source-pool and snapshot provenance. Holdout examples, check execution errors, duplicates and conflicts are not automatically turned into training examples. Stale previews are detected before applying the portion.
  • Clearer checks. Filters and groups distinguish model failures from check execution errors. Snapshot and portion forms are easier to use on narrow screens, while preserving the environment's structure.
  • Check the actual GGUF file. Run an exported file through the bundled CPU llama-server. Reports retain the full-file SHA256, runtime identity, answers and check coverage. Incomplete or errored runs are not reported as successful; unsupported checks have explicit explanations.
  • One heavy run at a time. Exported-model execution respects the environment's busy state to avoid overlapping an active run.
  • Daily launch counting removed. The program no longer sends a computer code and version to count running copies. License validation and author-signed update verification remain.
0.6.008.10.2026 — «Live net»
  • Apply live. Edited the net mid-training or after it (another activation, width, a new block) — press «Apply live». First a plan: which weights are kept, which new ones learn from scratch, which keep their optimizer state. Then training reaches a step boundary, writes a snapshot and continues THE SAME step with the new program. «Undo the edit» — a branch with the previous program from the same snapshot.
  • Time machine. Under the chart — a «History» strip: training snapshots (automatic, within a disk budget), program edits, branches, checks at every step. Click a snapshot — «Branch from here» (with the window's edit or without), «Check this state», «Compare the answer», «Example path», «Properties».
  • Model checks (an executable spec). The «Check» tab and mode: promises of the model — «for this input the answer contains / equals / starts with / is JSON with keys / ends in time / a number within / reference likelihood / your own Python function». They run by themselves at the end of every training (short ones — at every measure), on any snapshot and on the exported file. In the project's text — the checks: section.
  • «Make it a check» and «Pin the example» — right under the net's answer. A pinned example shows its answer at every measure: you see how it changes during training and after an edit.
  • Export and check. The same checks — on the training weights, on the exported folder (its code and compressed weights) and on ONNX, with the file's fingerprint: exactly what you hand over is checked.
  • Train on this. A red check → a short training branch with this example in the data; then — all checks (the guards show whether the old behaviour broke). Or on all red ones at once.
  • When did it turn red? From the history and snapshots (by binary search) — at which step and after which edit the check broke.
  • Answer difference. The same input on two states of the net: the answers side by side and how much each block's output changed.
  • «Do not touch» rule. «🔒 Do not touch» on a block: its weights do not train, at the end of training — proof that they did not move; a live edit that breaks them will not apply. In the text — protect:.
  • Model properties. Not examples but classes of bugs: same input — same answer; no peeking into the future (an answer leak in your own code); a text's beginning answers as in the long one; the answer does not depend on batch neighbours.
  • Minimal reproducible failure. Training went to nan — the doctor itself cuts the batch to one row and the shortest piece where the same block still produces the first nan, and puts сбой.py next to it in plain PyTorch — for an issue or a colleague.
  • The path of one example. Where the net errs on it (per token), which blocks its gradient pulls the most, whether that goes along with training (with the optimizer's momentum) and what one step on it alone would do.
  • Data as a program. In «What the net sees» — your own example by stages: raw text → the project's cleaning → tokenizer pieces → what goes into the loss → does it fit the window. It catches, for example, «lower case» cleaning that breaks the «Ответ:» marker.
  • Check the reward (training with a judge): before GRPO — does the right answer get more than someone else's, a cut one, an empty one and one with garbage after it. Otherwise the net will «hack» the reward.
  • Precision check. The same net in fp32 and in half precision, block by block: where rounding error accumulates.
  • ★ Where did this answer come from? (prototype). Which training examples pull the net towards a given answer the most (TracIn on a snapshot) — e.g. a wrong answer with garbage texts on top. An estimate of influence, not proof.
  • Result capsule («Ship ▾»): a zip — the program, the net in plain PyTorch, weights, checks with verdicts, how to reproduce.
  • Training survives a restart. Rebooted the computer mid-training — it continues from its last snapshot, not from scratch; a reopened window sees the running training again.
  • Experiments with checks: every branch shows its checks; a branch that improved the measure but broke a check is marked ✗.
  • Window: three modes in the header — **Net / Training / Check** (Alt+1/2/3); **Ctrl+P** — go to a block, check, problem; **Ctrl+Shift+P** — commands for the selection; **Alt+←** — back; arrows — to the neighbouring block along the strands; in a block's inspector the main settings are on top, rare ones folded; a project opens in the mode and with the lens where you worked.
0.5.1407.10.2026
  • A lighter window: six main tabs at the bottom, the rest under «More ▾»; under training, instead of ten small buttons — «Continue», «Fine-tune», «Check ▾» and «Ship ▾».
  • Any command: Space or Ctrl+K — training, debugging, lenses, shipping, tabs, Hugging Face, by name.
  • Right-click a block for a short menu (replace, copy, group, floors, own code, delete); right-click a strand to insert a block or remove the strand.
  • A «find a block…» search above the block palette: Enter adds the first match.
  • Esc closes dialog cards (computer check, treatment, Hugging Face and others).
0.5.1307.10.2026
  • The training debugger: the program not only trains a net but finds where training goes wrong, suggests a treatment and checks it.
  • Inserting a block into a strand no longer bends the schema: the new block sits between its neighbours and everything further along slides away smoothly.
  • Computer check («File ▾ → Check this computer»): is the GPU visible, do torch and the driver fit it, do a training step and half precision work, is there enough memory and space; in plain words, with a fix and a «Copy the report» button. On the first start the check runs by itself and shows up only if something is wrong.
  • Installer: if you already had a torch without GPU support (training silently ran on the processor, 10–50× slower), the installer asks and puts in the CUDA build. For RTX 50, a fresh torch that knows these cards.
  • One-batch check (the «One batch» button, half a minute): the same batch for 150 steps, can the net learn at least that. If not, the architecture or the training is broken, not the data. Your real training is not touched.
  • «What the net sees»: the real training batch, what goes in and what the net learns to predict (green is what goes into the loss). You see at once if a «question → answer» pair does not fit the window and teaches nothing.
  • «Treat…»: the doctor suggests schema edits (a norm before a dead block, a skip around a floor, the learning rate, gradient clipping). Apply them and training starts again, with «before» dashed and «after» on the chart. A treatment is an experiment: if it does not help, you see it.
  • Live pulse: while training, golden light runs along the strands from the output to the input; it is the real gradient. Where it fades, the block does not learn; dead parts go dark, nan flashes red.
  • The previous run stays on the chart dashed, so any edit can be compared «before/after» at the same step.
  • The training doctor. While training, the program checks every block of the net on its own (at step 20 and then regularly) and tells you in plain words what is wrong and what to fix: dead neurons (ReLU puts out only zeros), the gradient does not reach the start of the net or fades over the floors, values blow up, nan appears, the learning rate is too high or too low, the net starts memorizing. If a block suffers because of its neighbour, the doctor says so: fix the neighbour.
  • Is it really learning: the doctor checks that every block's weights belong to the optimizer and have moved since training started, and at the end that the weights file holds exactly the trained weights, not the old ones. Blocks frozen on purpose are not counted as errors.
  • The first nan: if the loss becomes a non-number, the doctor runs the same batch again and shows the block (and floor) where the non-number appeared first along the net; everything after it is marked as a consequence.
  • A run that diverged into nan: the window stopped showing its progress and hung on «running» (NaN was written into the log, and NaN is not JSON); now everything is shown up to the summary. And it no longer crashes at the very end on the sample text.
  • The «health» lens: blocks on the scene glow green, yellow or red; select a block to see its numbers and advice on the right.
  • «Model from Hugging Face»: for models with windowed attention (Mistral, Gemma 3, gpt-oss) «window up to» was computed as if the window memory grew forever; in fact windowed floors stop growing at the window length. Now it is right: for example, Gemma 3 4B in 4 bits on a 6 GB card holds the whole 128k window, not 21k.
0.5.1207.10.2026
  • New: «File ▾ → Model from Hugging Face…». Type the name of any open model (Qwen/Qwen3-8B, deepseek-ai/DeepSeek-V3, openai/gpt-oss-20b) and in a second you see its architecture in 3D: floors, attention windows, experts, latent attention. And a table: how many weights it has, how many work for each token, how much memory it needs at 16, 8 and 4 bits together with the conversation window, and whether it fits YOUR GPU and up to which window. No weights are downloaded, only the model's description (kilobytes).
  • The same in the console: zhele hub Qwen/Qwen3-8B --context 8192.
0.5.1107.10.2026
  • Install: torch is installed at a tested version. Without an NVIDIA card the installer used to pull the newest torch, which the program had not been tested on; now it installs 2.5.1, same as the author's.
  • RTX 50 cards: the installer now picks torch with CUDA 13 for them (the old build did not support these cards).
  • The installer also installs onnxruntime: without it the number check on ONNX export and import was silently skipped.
  • The program is also tested on the latest torch 2.14, so if you already have your own torch, it works on it too. Found and fixed: ONNX export on torch 2.9+ needed the extra onnxscript package; ONNX and PyTorch-code import on torch 2.6+ split the net's floors into pieces.
  • A bubble with several outputs: if the next bubble took the second output, the program saved but would not open again. Fixed.
  • The net's sample text no longer shows «�» in the middle of words.
0.5.1006.10.2026
  • Gift codes: a one-time code like ZG-XXXX-XXXX-XXXX goes into the key field — the key installs on the computer where the code is entered first.
  • «About»: a «new key» field — enter a bought key or a gift code without leaving the program.
0.5.906.10.2026
  • Before the first start you agree to the terms (a checkbox on the first screen); the full terms open right from the program and live at zhele.tech/terms.
  • Historical 0.5.9 feature: daily reporting of the computer code and version. Since 8 October 2026 the service no longer records device or launch statistics; older installed versions may still send the request. Daily reporting has been removed in the new candidate.
  • English window: the training chart legend is in English. News and releases: t.me/zhele_air.
0.5.806.10.2026
  • Built-in helper (beta): edits the program from a request in words; its brain is zhele_ai, the author's language model. The new version does 11 of 20 edits on its exam. The helper package downloads itself, with your key.
  • Keys now come from key.zhele.tech, the site lives at zhele.tech; the old address keeps working.
0.5.705.10.2026
  • The key right inside the program: on the first screen «Get a trial key» (7 days, instantly) and «Subscribe» — pay in the browser, the key installs itself, renewals too. The Telegram bot @zhele_keybot is a backup.
  • Keys from the cloud bot (ZA2) are accepted: it works around the clock, and the author's key never leaves the author's computer.
  • English window: the course in English («Why» on every step), check hints translated, «step» instead of «stride».
0.5.604.10.2026
  • New scene look «fiber»: the whole net is one jelly strand with a glowing core, blocks are bulges on it; drag a wire and the nearest input pulls it in. The old look — «File → Scene look».
  • The course «your own language model from scratch» as a card next to the scene: it stays put, folds into one line, every step has «Where is it?».
  • Every course step has «Why»: what this step does to the net; after an action the card shows what changed (weights, memory, window, measure) and what it means.
  • An access key is tied to a computer (the computer's code is in «About»); old keys work until they expire.
0.5.504.10.2026
  • New name — zhele (was zhele_air). Shortcuts, installer and window were renamed automatically; projects and key stay in place.
0.5.404.10.2026
  • Nets from TensorFlow, Keras and JAX via ONNX: «File → Import ONNX…», the output is checked against onnxruntime.
  • Textbook and window guide in English: other people's nets, Python, folding repeats.
0.5.304.10.2026
  • Bring your own PyTorch code into blocks: «File → Import PyTorch code…» (with weights; attention, transformer, GRU and LSTM become our own blocks).
  • Identical floors in a row fold into one «Repeat ×N» and unfold back.
  • zhele from Python and Jupyter: zhele.compile("model.zhele") is an ordinary nn.Module.
  • AI assistants (via MCP) can save their own blocks to the library.
0.5 – 0.5.203.10.2026
  • Auto-updates: a new version installs itself; the author's signature and checksums are verified before installing.
0.403.10.2026
  • First released version: Windows installer, access keys, the zhele language, compiler and environment.
Download

Install and get a key

SystemWindows 10 or 11, 64-bit
Graphics cardNVIDIA trains faster; without one it runs on the CPU
Disk spaceWindows installer: approximately 32.4 MB; unpacked zhele files: approximately 90.4 MB. Additional space for Python, PyTorch, required dependencies, models and runs depends on the environment.
Internetduring installation to download missing CPython 3.12 x64 and required dependencies

The installer sets up Python 3.12 and PyTorch if they are missing. The first dependency download needs additional time and disk space. Other Python versions are not affected.

  1. Download and run the installer. A PowerShell command is also available: irm https://zhele.tech/install.ps1 | iex. The installer is not yet Authenticode-signed; Windows may show a warning or block it.
  2. Open zhele and press «Get a trial key» — a free week, the program gets the key by itself.
  3. Like it — press «Subscribe» right there: $5 a month or $49 a year. Available payment methods are shown at checkout. The key and renewals install themselves.
This is a beta. The installer does not yet have an Authenticode signature, so Windows may show a warning. If something breaks, send the steps and a screenshot. Early subscribers keep their price. A key is tied to one computer; to move it, use support or the bot.

Usage statistics removed; licensing remains

Version 0.6.1 does not send device or launch statistics. Older 0.6.0 clients may still send the previous request, but the server does not record it. To issue and renew a key, the licensing service uses the computer code and an install secret; the key remains tied to a computer. See the terms of use for details. Terms of use (also LICENSE.md in the program folder)

Mac and Linux are coming. News and releases — t.me/zhele_air.

Share your first experiment

Project news, demonstrations and questions for the author. Tell us which example you ran and what happened.