Skip to content
Jennifer Programming Language
Jennifer

Jennifer Programming Language

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

It is batteries-included: 41 built-in libraries and 74 distributable modules - over 1,800 functions, constants, and types cover what real programs actually need. 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 implemented, not stubbed: 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. More niche needs are covered too - Gotify push, strict SemVer, S3 object storage, vCard / iCalendar, MQTT and AMQP messaging, ACME certificate issuance, TOTP two-factor codes. 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 nothing else to install to run everything built in: no separate runtime, and no dependency tree to resolve first. 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. Reaching past the built-ins is opt-in: third-party decks (Jennifer's packages) are vendored into your project's own tree - no global install, no daemon - with the jvc package manager to resolve and pin them.

It also works well for teaching and learning: an interactive REPL, an easy-to-read grammar, and token and AST dumps show what an interpreter does at each stage, 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 - so a mistake shows up as a clear message rather than silent misbehavior, and a learner can see 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.