explaingit

baileywickham/jixp

Analysis updated 2026-07-26

1PythonAudience · developerComplexity · 4/5Setup · moderate

TLDR

A small programming language that compiles simple, Lisp-style neural network definitions into standalone Python code using JAX or MLX, with a built-in interactive visualization tool.

Mindmap

mindmap
  root((repo))
    What it does
      Compiles Lisp to Python
      No runtime dependency
      Generates JAX or MLX code
    Core architecture
      Parser for s-expressions
      Evaluator for arithmetic
      Compiler outputs Python files
    Use cases
      Train XOR network
      MNIST classifier
      GPT on Shakespeare text
    Visualization
      Interactive HTML explorer
      Collapsible tree view
      Exact parameter counts
    Tech stack
      Python
      JAX
      MLX

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Define and compile a GPT-style language model into readable Python code.

USE CASE 2

Train a small image classifier on the MNIST dataset.

USE CASE 3

Generate a standalone HTML visualization of a neural network's architecture.

USE CASE 4

Compile models to run natively on Apple silicon GPUs using MLX.

What is it built with?

PythonJAXMLXLisp

How does it compare?

baileywickham/jixp0xustaz/streamgatea-bissell/unleash-lite
Stars111
LanguagePythonPythonPython
Setup difficultymoderatehardhard
Complexity4/54/54/5
Audiencedeveloperdeveloperresearcher

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · moderate Time to first run · 30min

Requires understanding of Lisp syntax and JAX/MLX frameworks to define and run the compiled models.

No license information was provided in the explanation, so usage rights are unknown.

In plain English

jixp is a small programming language for describing neural networks. You write model definitions in a Lisp-like syntax, then compile them into standard Python files that use JAX, a popular library for numerical computing. The generated code has no runtime dependency on jixp itself, so the language acts purely as a build step. The project is built in three layers. First, a parser reads s-expressions, the parenthesized syntax common in Lisp, and converts them into plain Python lists. Second, an evaluator provides basic Lisp features like conditionals, function definitions, and arithmetic. Third, a compiler takes model descriptions written in this language and produces a Python module with functions for initializing parameters and running the model. The compiler uses the evaluator from the second layer to compute dimension values at compile time. The example in the README shows a GPT-style language model defined in jixp. You specify dimensions like vocabulary size and layer count, then describe the model as a sequence of blocks including embeddings, attention layers, and normalization steps. Running the compiler produces a readable Python file where each defined block becomes a pair of functions, one for initialization and one for applying the model to input data. Training code imports this generated module and uses ordinary JAX functions for gradients and optimization. jixp also includes a visualization feature. Compiling with a flag produces a standalone HTML file with an interactive explorer showing the model structure as a collapsible tree, a flow diagram, and a parameter map. The tool computes exact parameter counts for each part of the model. The README includes examples for training a small network on XOR, an MNIST classifier reaching about 98 percent accuracy, and the GPT model trained on Shakespeare text. The compiler can also target MLX, a framework for running models on Apple silicon GPUs. The generated MLX code matches the JAX version numerically, with tests confirming the outputs agree. The full README is longer than what was shown.

Copy-paste prompts

Prompt 1
Write a jixp model definition for a simple convolutional neural network that classifies MNIST digits, including the dimensions and layer blocks.
Prompt 2
Show me how to compile a jixp model definition into a Python file using JAX, and write the training loop to optimize it on a dummy dataset.
Prompt 3
Create a jixp definition for a small transformer model and compile it with the visualization flag to generate an HTML parameter map.
Prompt 4
Explain how to use jixp to compile a model for MLX instead of JAX, and write the Python code to run inference with the generated MLX module.

Frequently asked questions

What is jixp?

A small programming language that compiles simple, Lisp-style neural network definitions into standalone Python code using JAX or MLX, with a built-in interactive visualization tool.

What language is jixp written in?

Mainly Python. The stack also includes Python, JAX, MLX.

What license does jixp use?

No license information was provided in the explanation, so usage rights are unknown.

How hard is jixp to set up?

Setup difficulty is rated moderate, with roughly 30min to a first successful run.

Who is jixp for?

Mainly developer.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.