Skip to content
Jennifer Programming Language
Jennifer

Jennifer Programming Language

Jennifer is an interpreted programming language written in (Tiny)Go.

It is batteries-included, and not just in name: 41 built-in libraries and 72 distributable modules - over 1,800 functions, constants, and types cover what real programs actually need, so you build genuine tools, not toys. Talk to a real database with the SQL library (MySQL/MariaDB/Galera and PostgreSQL, parameterized and injection-safe) or map rows to structs with the ORM. Read and write JSON, YAML, TOML, and XML; match text with full regular expressions. The web works both ways: an HTTP/S client and ergonomic REST layer to call out, a built-in HTTP server and web framework to serve. Email is a complete stack - SMTP to send, POP3 / IMAP to receive; caches and stores come through Redis and memcached clients. Security is the real thing, not a stub: AES-256-GCM, Ed25519, HKDF / PBKDF2, and JWT. Wire your program into AI agents with the Model Context Protocol: expose your own functions as tools / resources / prompts to a host (Claude, an IDE, ...), or call another MCP server as a client - validated end to end against the official MCP SDK. And lightweight concurrency is built into the language via spawn and the task library. Something more niche - Gotify push, strict SemVer, S3 object storage, vCard / iCalendar, MQTT and AMQP messaging, ACME certificate issuance, TOTP two-factor codes - and lots of others? No need to ask: it is all there already. The interpreter and its built-in libraries ship as one self-contained static binary - about 23 MB with everything, ~10 MB for the embeddable build - with no runtime, package manager, or dependency tree to install; the modules ride along as plain .j source files (installed beside the binary and resolved through the module path), readable and hackable with no compile step.

It is also a natural fit for teaching and learning: an interactive REPL, an easy-to-read grammar, and token and AST dumps that make it ideal for mastering language design, plus a built-in linter and profiler and full test support. Its strict, explicit design - conditions must be bool, conversions are spelled out, names never shadow, and errors are positioned - surfaces a mistake as a clear message instead of a silent surprise, so a learner sees exactly what went wrong.

Source files use the .j extension. Whitespace is not significant anywhere; statements end with ;.

jennifer
use io;
use time;

def start as time.Time init time.now();
io.printf("hello, world\n");
def gap as time.Duration init time.sub(time.now(), $start);
io.printf("ran for %d ms\n", time.milliseconds($gap));

Two binaries: jennifer and jennifer-tiny

Jennifer ships as two binaries built from the same source:

  • jennifer - standard Go build, full host-feature surface. This is the default binary you install and reach for.
  • jennifer-tiny - TinyGo build, smaller and embeddable. Missing os/exec and the network stack (TinyGo runtime gaps); calls into those surfaces return a friendly runtime error pointing back at jennifer. Use this variant when binary size or embeddability matters (embedded systems, minimal containers, small-footprint scripting hosts).

Write Jennifer with your editor and an AI assistant

Syntax highlighting ships in editors/ (a Vim / Neovim drop-in, a TextMate grammar for VS Code / Sublime / Zed, a highlight.js definition). And because Jennifer is new, we ship JENNIFER.md: drop it into your project and point an AI coding assistant at it ("we code in Jennifer, see JENNIFER.md, let's go") so it writes correct .j from the start. See Editor & AI support.

What's in this site

  • Getting started - install the interpreter and run your first program.
  • Editor & AI support - highlighting and the drop-in JENNIFER.md for AI-assisted coding.
  • Language reference - syntax, types, methods, control flow, imports, style.
  • Libraries - per-library reference plus an alphabetical cheatsheet of every builtin.
  • Modules - the Jennifer-coded, importable module ecosystem (import "name.j";): formats, mail, stores, web, and protocol clients, each with its own reference page.
  • Technical reference - implementation details for the lexer, parser, interpreter, and CLI.
  • Project - milestones, design stances, glossary.

Status

Pre-1.0. The major version stays at 0.x.y while the language is still finding its shape; breaking changes can happen at milestone boundaries and are called out in docs/milestones.md. Once Jennifer reaches 1.0.0, semver applies and breaking changes need a major bump.

Source

Source, issues, and pull requests live at https://github.com/jennifer-language/jennifer.

License: LGPL-3.0-only.

Manual

Download the whole manual as a single PDF. It ships with a clickable outline (the H1/H2/H3 headings) in your PDF reader's bookmark panel, so you can jump straight to any section. The entire documentation in one file, regenerated from these pages on every build - handy for reading or searching offline.