Mutz is a runtime and programming framework that empowers anyone to build software that they can trust and understand via AI coding agents.

Mutz programs are written in Lua. They can run basically anywhere, including;

• inside your company’s legacy apps
• in brand new apps
• in web servers
• inside your web browser
• inside mobile apps
• on embedded devices
• Mutz itself is written in Zig; it can run on any target platform that Zig can compile to

function main()
  -- Use a mut to interact with input, output, the internet, the UI, or
  -- anything else.
  mut('print', 'Hello, world!')

  -- A mut can hide unnecessary details about how the email is sent.
  -- Traditional tech personas own the code "under the hood."
  mut('email', {
    to = "[email protected]",
    body = "Hello, world!"
  })

  -- Custom mutz can facilitate any imaginable operation.
  mut('send-snail-mail', {
    to = "123 Street Lane\nCity, ST 12345",
    body = "Hello, real world!"
  })
end

Mutz enforces a coding model where behavior and mutations are strictly separated. This allows people who do not come from a traditional software development background to deeply, meaningfully, and directly contribute to the software development lifecycle of existing applications or build their own applications from scratch.

Mutz builders will focus on expressing and validating behavior while people with traditional technical backgrounds focus on creating and governing the use of mutations, which we call “Mutz.”

Packaged Mutz

Packaged Mutz are pre-packaged sets of mutations which Mutz software creators can use to make apps. In general, it’s assumed that mutations will be built by people who come from traditional technical backgrounds, and their use may be governed by your organizations’ Security teams or IT systems administrators. However, Mutz can and should be shared. They go especially well on pizza.

Mutz Code

In Mutz, AI writes lua code like this;

function handle_click(context)
  if !is_valid(context.form) then
    return mut(
      'notify',
      'Oops, you forgot ' .. list_missing_fields(context.form)
    )
  end
end

Mutz code is strongly sandboxed. It has no internet access and no access to your files. The only way that Mutz code can interact with the real world is by returning a mutation back to the runtime. We call this a, “mut,” for short (plural “Mutz”).

In the example above, our app has one mut called 'notify'. The backend code behind this mut would vary based on the type of app. In a mobile app backend, it might fire off a request to Firebase Cloud Messaging. In a web browser, it might simply call alert() or interact with the app’s UI library.

A mut can return data back to the Mutz program after it’s completed.

function finish_checkout(context)
  payment = mut('take-payment', context.wallet)
  if (payment.ok) then
    mut('fulfill', context.order)
  else
    mut(
      'notify',
      'Payment rejected. Please try again, or change your payment method!'
    )
  end
end

Mutz is a high-performance native library. The underlying runtime is Luajit, and the Mutz runtime itself is written in Zig. This means that in web, mobile, and backend apps, you can integrate Mutz using the C ABI for your platform (Linux, Windows, or macOS). On the web, you can compile Mutz to WASM and run it in a web browser.