hotgrin

hotgrin programming language

The programming language that makes you grin.

hotgrin is a free, open-source programming language that reads like plain English — and compiles to a real, fast program. Learn to code without fighting punctuation. Ship a genuine Windows .exe when you’re done

▶ Try it in your browser — nothing to install

▶ Get started in 5 minutes: read all about it

▶ Get all the info on Github.

▶ Use hotgrin in your AI! Just send your AI agent here: hotgrin and AI.

▶ Open source (MIT) · Built on Go · Errors explained kindly in English or Afrikaans

THE TASTE

See a complete program

action discount with price, percent
    give back price minus (price times percent divided by 100)
end action

set total to 897
say "Total: R" plus total
say "After 10% off: R" plus discount with total, 10

The result is:

Total: R897
After 10% off: R807.3

> No semicolons. No curly braces. No boilerplate.
> Names can have spaces — cart total is one name, the way you’d say it.
> Maths behaves like school maths — divided by gives a decimal, brackets group.
> plus just works — joins text, adds numbers, converts between them for you.

WHY HOTGRIN

Why people choose hotgrin

If you’re new to programming:

> Write your first working program in minutes, not evenings — the tutorial takes you from zero to sharing your own program.
> Mistakes are explained kindly and precisely: “there is no value called ‘totall’ here — is it a typo, or did you forget to set it?” Never a wall of compiler jargon.
> Learn in English or Afrikaans — the only language we know of with first-class Afrikaans error messages.
> Try everything in the browser playground before installing anything at all.

If you can already program:

> hotgrin transpiles to real Go — inspect the output any time with hotgrin reveal. Nothing is hidden, ever.
> Testing is part of the language, not a bolt-on: test "..." blocks with expect ... to be ... assertions, run by one command.
> Failures can’t be silently ignored — fallible actions must be handled, enforced before the program runs.
> Structured concurrency (at the same time ... end at the same time) compiles to goroutines with the shared-state guarded for you.
> Cross-compile a Windows .exe from any machine with one flag.
> The whole language is a small, readable Go codebase —
read it, 91+ tests, CI on every commit.

If you teach:

> Line-by-line syntax with explicit end blocks — nothing invisible, nothing implied.
> The Watcher checker never raises a false alarm, so learners trust it.
> A verified cookbook of 21 copy-paste recipes and a complete worked project ready for the classroom.

THE REVEAL

Nothing is hidden

Your program becomes real Go — the language behind Docker and Kubernetes:

say "Hello, world"

results in:

package main

import "fmt"

func main() {
    fmt.Println("Hello, world")
}

Run hotgrin reveal yourprogram.hot and read the Go behind it. Learn gently now, peek under the bonnet whenever curiosity strikes — and outgrow nothing: the skills transfer.

THE WATCHER

Mistakes, explained kindly — in two languages

Every program is checked by the Watcher before it runs.

Its iron rule:
it only speaks when it can prove something is wrong. No false alarms, no nagging — so when it speaks, you listen.

English:

error  line 2: there is no value called 'totall' here —
       is it a typo, or did you forget to set it?

Afrikaans:

error line 2: daar is geen waarde genaamd 'totall' hier nie —
       is dit 'n tikfout, of het jy vergeet om dit te stel?

> Catches typos, wrong argument counts, divide-by-zero, unreachable code, unused values, unhandled failures — before anything runs.
> You will never see a raw compiler error. That’s a promise built into the design.
> More languages are on the roadmap — native speakers welcome to contribute.

PHILOSOPHY

The philosophy of hotgrin

Five beliefs shape every decision in the language:

  1. Reading beats memorising
    Code should read the way you’d explain it aloud. if score is at least 50 —
    you already knew what that does. The fewer symbols between your idea and the computer, the sooner you’re actually programming.
  2. Kind is not the same as vague
    Friendly errors are precise errors. The Watcher points at the exact line, in plain words, and never guesses. Kindness that sacrifices truth would be a toy; hotgrin refuses to be a toy.
  3. A beginner’s language must not have a ceiling
    hotgrin compiles to Go — the same technology running serious global infrastructure. The language you learn on Saturday is one you could genuinely build with on Monday. And reveal means you can see the bridge to
    professional code whenever you’re ready to cross it.
  4. Small core, honest edges
    The language itself stays small and consistent. Reach comes from libraries, not from bolting features onto the core. And when something isn’t built yet, hotgrin says so plainly — check the public roadmap.
  5. Your language is welcome here
    Learning lands deepest in your own tongue. English and Afrikaans ship today; the mechanism is built for more. Programming education shouldn’t have a language barrier — especially not in South Africa, where hotgrin was born.

FEATURES GRID

Everything in the box:

> Variables & maths that behave
set cart total to 0, increase score by 10 — and 7 divided by 2 is 3.5, because that’s what you meant.

> Decisions & loops in plain words
if ... else ... end if · repeat 3 times · repeat while ·
repeat for each learner in class.
> Records that describe things
describe order ... end describe, then read fields naturally: price of order.
> Actions (your own commands)
Define once with action, reuse everywhere, give back results. Types are inferred — no annotations to learn.
> Built-in testing
test "it works" with expect ... to be ... — one command runs them all.
> Honest error handling
give back problem "..." + try / if it fails — and unhandled failures are caught before the program runs.
> Safe concurrency
at the same time blocks run work in parallel, with shared results collected safely by design.
> Real programs out
hotgrin build --windows makes a genuine .exe anyone can run — nothing to install on their side.
> Command-line inputs, free --help
input name as text default "world" — your program gets professional --flags automatically.

HOW TO START

How to start (pick your path)

Path 1 — Zero install (30 seconds)

> Open the playground.
>Type on the left; watch real Go appear on the right.
>Flip the Watcher to Afrikaans if you like. Everything runs in your browser.


Path 2 — One command (if you have Go)

> Install Go 1.22+ — one installer, one time.
> Run:

   go install github.com/hotgrin/hotgrin/cmd/hotgrin@latest

> Check: hotgrin version


Path 3 — Download a binary

> Grab your platform’s file from the latest release (Windows, Linux, macOS).
> Unzip it onto your PATH. (You’ll still want Go installed — hotgrin uses it to compile your programs.)
> Your first program (2 minutes)
Make a file hello.hot:

   say "Hello, world"
   set name to "Adriaan"
   say "Welcome, " plus name

> hotgrin run hello.hot
> hotgrin check hello.hot — meet the Watcher (try --af).
> hotgrin build --windows hello.hot — now send someone your .exe. 😁

→ https://github.com/Hotgrin/hotgrin/blob/main/docs/getting-started.md

LEARN MORE / DOCS HUB

> Learn hotgrin
> Getting started — install and first program, three ways.
> The gentle tutorial — from zero to sharing your own .exe, ten friendly steps.
> The cookbook — 15 copy-paste recipes; every one verified to run exactly as shown.
> The language reference — every construct, with its Go mapping, for experienced developers.
> A complete worked project — a real loan calculator with inputs, actions, and tests.
> Example programs — small, runnable .hot files.

OPEN SOURCE / COMMUNITY

> Open source, built in the open hotgrin is MIT-licensed and developed publicly. Come look under the hood — or lend a hand:
> Source code — the whole language: lexer, parser, transpiler, checker. 91+ tests, CI green on every commit.
> Releases — prebuilt binaries for Windows, Linux, and macOS, published automatically.
> Roadmap — what’s next and why, prioritised by real use.
> Report a bug / request a feature — every issue is read.
> Contributing guide — two house rules: every change ships with a test, and the Watcher never raises a false alarm.
>Security policy ·
> Changelog ·
> MIT licence
> Good first contributions: a cookbook recipe · an example program · a Watcher rule (with its no-false-alarm proof) · >error-message translations into your language.

FAQ

Frequently asked questions

> Is hotgrin free?
Yes — completely free and open source under the MIT licence, for any use.
> Do I need to install anything to try it?
No. The browser playground runs entirely in your browser and shows you the generated Go plus the Watcher’s checks. To run programs on your computer, install Go (one
installer) and hotgrin (one command).
> Is it a toy language?
No. hotgrin programs compile — via Go — to real native executables, including Windows .exe files you can hand to anyone. Testing, error handling, and safe concurrency are part of the language. It is young (v0.5.6, alpha), and the
roadmap is public.
> Why does it need Go installed?
hotgrin translates your program into Go and uses the Go toolchain to compile it. That’s how a friendly language gets professional-grade speed and cross-platform builds. (A no-install interpreter mode is on the roadmap.)
> What does “errors in Afrikaans” mean?
Add --af to any check and the Watcher explains problems in Afrikaans: “daar is geen waarde genaamd ‘totall’ hier nie — is dit ‘n tikfout?” — the same precision, in your language. More languages are planned.
> Can I use it for serious work?
It’s early-alpha: perfect for learning, teaching, hobby projects, and small real tools (the loan calculator
is a working example). For production systems, watch the roadmap — and the Go it generates is always yours to keep.
> Windows, Mac, or Linux?
All three. Prebuilt binaries ship for each on the releases page, and any machine can cross-compile a Windows .exe.
> Who makes hotgrin?
hotgrin is created by Adriaan (AJ) Louw in Johannesburg, South Africa, and developed in the open on GitHub.

ABOUT

About hotgrin

hotgrin started with a simple frustration: the first hour of programming shouldn’t be about semicolons.

Most tools solve that by being toys — hotgrin refuses. It reads like English and compiles to the technology behind serious
software, so nobody ever has to throw away what they learned here.
It’s made in Johannesburg, South Africa 🇿🇦, speaks English and
Afrikaans, and is built in the open — every commit, every test, every
decision public.

It’s version 0.5.6 and honestly alpha: small standard library, rough edges, big plans. Come play, come break it, come tell us what confused you — that’s literally how the roadmap gets written.

Ready to grin?

[ ▶ Open the playground ] [ Get started → ] [ ⭐ Star on GitHub ]:

playground URL · getting-started URL: https://github.com/Hotgrin/hotgrin

hotgrin — the language that makes you grin.


Playground · Docs · GitHub · Releases · Roadmap · Issues · Contributing


Open source under the MIT licence.

Made with a grin in South Africa. 🇿🇦