PyMini

What it is

PyMini is a Python-subset interpreter written in Swift and built into the keyboard. Every custom panel and every custom action runs on it. It reads the shape of Python you already know, and the same language serves whether a script draws an interface or rewrites a word.

# an action: text in, text out
def transform(text):
    return text.upper()

# a panel: a view, and what a tap does
def view(state):
    return button("Shout", "shout")

def on_action(action, state):
    insert(context()["word"].upper())
    return state

Why use it

We built PyMini because Clink needed a way for people to script their own keyboard, and nothing we found would fit inside one. Nothing about it is tied to keyboards, though, so it is now open source as its own Swift package, for any app that wants to let its users write a little Python.

It is not CPython, and it does not embed it. A keyboard extension gets a fraction of the memory an app does, and CPython's binary and heap would spend that budget before your script ran. PyMini is a few hundred kilobytes of Swift with no binary dependencies.

Reach for it wherever users want logic of their own: text transforms in a writing app, rules in a to-do or budgeting app, formulas, automations, game mods, or a plugin system for an app with a community around it. Plenty of people already know some Python, so there is no new language to teach, and a script is plain text you can store, sync and share like any other setting.

import PyMini

let py = PyRuntime(modules: ["math", "json", "re"])

// your app, as a Python function
py.define("shout") { call in
    try call.argument(0, as: String.self).uppercased()
}

// a script one of your users wrote
try py.load("""
def tidy(text):
    return shout(" ".join(text.split()))
""")

try py.call("tidy", "  hello    there ")  // HELLO THERE

The source, the language reference and the tests are on GitHub.

What it promises

There is no filesystem, no network and no process for a script to reach: the sandbox is the shape of the interpreter, not a list of things it refuses. import is the one door out, and it opens onto a short list of namespaces that only compute. Everything else costs steps. Every expression, every turn of a loop, every regular-expression step and every line of JSON spends one of 2,000,000, and strings and lists are capped as they grow.

The budget cannot be caught. An except clause catches a KeyError; it does not catch the abort that ends a runaway loop, because catching it is exactly how a runaway script would carry on running.

Changelog

Each version of PyMini, newest first, and what it added.

import re

def initial():
    return {"words": []}

def view(state):
    top = sorted(set(state["words"]), key=lambda w: -len(w))[:3]
    return vstack([text(f"{len(state['words']):,} words", mono=True)]
                  + [row(w, detail=f"{len(w)}") for w in top])

def on_open(state):
    state["words"] = re.findall(r"\w+", context()["before"])
    return state

Where to go next

The language surface in full, the panel vocabulary, and a builder that writes both without you typing a line.