PHP, Python, Ruby, C#, Java,
Node, Rust — one file

# Python: standard library only (ctypes). The whole binding.
db = InlaySQL('./libinlaysql_ffi.so', 'app.inlay')   # .dylib on macOS
db.run('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)')
db.run('INSERT INTO users (name) VALUES (?)', ['Ada'])
print(db.run('SELECT id, name FROM users')['rows'])

import ctypes, json

class InlaySQL:
    def __init__(self, lib_path, db_path):
        self.lib = ctypes.CDLL(lib_path)
        lib = self.lib
        lib.inlaysql_open.argtypes = [ctypes.c_char_p];  lib.inlaysql_open.restype = ctypes.c_void_p
        lib.inlaysql_exec.argtypes = [ctypes.c_void_p, ctypes.c_char_p,
                                      ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p)]
        lib.inlaysql_exec.restype = ctypes.c_int
        lib.inlaysql_last_error.restype = ctypes.c_char_p
        lib.inlaysql_free_string.argtypes = [ctypes.c_char_p]
        lib.inlaysql_close.argtypes = [ctypes.c_void_p]
        self.handle = lib.inlaysql_open(db_path.encode())
        if not self.handle:
            raise RuntimeError(lib.inlaysql_last_error().decode())

    def run(self, sql, params=None):
        out = ctypes.c_char_p()
        code = self.lib.inlaysql_exec(self.handle, sql.encode(),
            json.dumps(params).encode() if params is not None else None,
            ctypes.byref(out))
        if code != 0:
            raise RuntimeError(self.lib.inlaysql_last_error().decode())
        result = json.loads(out.value)
        self.lib.inlaysql_free_string(out)
        return result

Runnable: poc.py in the release archive.

# Ruby: one gem (gem install ffi). The whole binding.
db = InlaySQL.new('app.inlay')
db.run('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)')
db.run('INSERT INTO users (name) VALUES (?)', ['Ada'])
p db.run('SELECT id, name FROM users')['rows']

require 'ffi'; require 'json'

class InlaySQL
  module Native
    extend FFI::Library
    ffi_lib File.expand_path('./libinlaysql_ffi.dylib', __dir__)
    attach_function :inlaysql_open, [:string], :pointer
    attach_function :inlaysql_close, [:pointer], :void
    attach_function :inlaysql_exec, [:pointer, :string, :string, :pointer], :int
    attach_function :inlaysql_last_error, [], :string
    attach_function :inlaysql_free_string, [:pointer], :void
  end

  def initialize(db_path)
    @handle = Native.inlaysql_open(db_path)
    raise "open failed: #{Native.inlaysql_last_error}" if @handle.null?
  end

  def run(sql, params = nil)
    out = FFI::MemoryPointer.new(:pointer)
    code = Native.inlaysql_exec(@handle, sql, params && JSON.generate(params), out)
    raise Native.inlaysql_last_error unless code.zero?
    result = JSON.parse(out.read_pointer.read_string)
    Native.inlaysql_free_string(out.read_pointer)
    result
  end

  def close = Native.inlaysql_close(@handle)
end

Runnable: poc.rb in the release archive.

use inlaysql::{Database, Value};

let mut db = Database::open("app.inlay")?;

db.execute("CREATE TABLE IF NOT EXISTS docs (
    id INTEGER PRIMARY KEY, title TEXT, body TEXT)", &[])?;

db.execute("INSERT INTO docs (title, body) VALUES (?, ?)",
    &[Value::Text(title.into()), Value::Text(body.into())])?;

let rows = db.query("SELECT id, title FROM docs WHERE id = ?",
    &[Value::Integer(id)])?;

Crate: inlaySQL/inlaysql — #![forbid(unsafe_code)], thread-per-handle MVCC.

import { openDatabase } from "@inlaysql/core";
import { opfs } from "@inlaysql/storage";
import { defineModel, field, install, repo } from "@inlaysql/orm";

const Page = defineModel("pages", {
  id: field.integer().primaryKey(),
  body: field.text().index("bm25"),
  embedding: field.vector(384).index("hnsw").embedFrom("body"),
});

const db = await openDatabase({ source: opfs("app.inlay"), create: true });
await install(db, Page);
await repo(db, Page).insert({ body: "full text" });  // embedding computed

const hits = await repo(db, Page).search("full text", { mode: "hybrid" });

Runs in Node, Deno, Bun, the browser and edge runtimes. Live: the SDK demo. Repo: inlaySQL/inlaysql-js.

import pymysql  # or mysqlclient; SQLAlchemy: mysql+pymysql://…

conn = pymysql.connect(
    host="127.0.0.1", port=3306,
    user="inlaysql", password=os.environ["INLAYSQL_PASSWORD"],
)

with conn.cursor() as cur:
    cur.execute("INSERT INTO docs (title, body) VALUES (%s, %s)", (title, body))
    cur.execute("SELECT id, title FROM docs ORDER BY id LIMIT 20")
    for row in cur.fetchall():
        print(row)

Django/SQLAlchemy point their mysql backend at the server; the SQL surface caveats are documented.

require "mysql2"

client = Mysql2::Client.new(
  host: "127.0.0.1", port: 3306,
  username: "inlaysql", password: ENV["INLAYSQL_PASSWORD"],
)

statement = client.prepare("INSERT INTO docs (title, body) VALUES (?, ?)")
statement.execute(title, body)

client.query("SELECT id, title FROM docs ORDER BY id LIMIT 20")
      .each { |row| puts row["title"] }

Rails: point database.yml at the server with the mysql2 adapter.

using MySqlConnector;

await using var conn = new MySqlConnection(
    "Server=127.0.0.1;Port=3306;User ID=inlaysql;Password=…");
await conn.OpenAsync();

await using var cmd = new MySqlCommand(
    "INSERT INTO docs (title, body) VALUES (@t, @b)", conn);
cmd.Parameters.AddWithValue("@t", title);
cmd.Parameters.AddWithValue("@b", body);
await cmd.ExecuteNonQueryAsync();

Entity Framework: the Pomelo.EntityFrameworkCore.MySql provider rides the same wire. MySqlConnector speaks the binary protocol, which is how BLOB values are written.

try (Connection c = DriverManager.getConnection(
        "jdbc:mysql://127.0.0.1:3306/app", "inlaysql", password);
     PreparedStatement insert = c.prepareStatement(
        "INSERT INTO docs (title, body) VALUES (?, ?)")) {

    insert.setString(1, title);
    insert.setString(2, body);
    insert.executeUpdate();
}

Hibernate, jOOQ, MyBatis ride the same wire. JDBC uses the binary protocol — the one path that accepts BLOB writes today.

import mysql from "mysql2/promise";

// The other Node direction is embedding — see the tabs above, or the
// live SDK demo. Over the wire:
const conn = await mysql.createConnection({
  host: "127.0.0.1", port: 3306, user: "inlaysql",
  password: process.env.INLAYSQL_PASSWORD,
});

await conn.execute("INSERT INTO docs (title, body) VALUES (?, ?)", [title, body]);
const [rows] = await conn.query("SELECT id, title FROM docs ORDER BY id LIMIT 20");

Node has both directions: the WASM SDK in-process, or mysql2 when one server process should own the file.