AI is changing the world. Don't stay behind. Clear summaries, community insight, delivered without the noise. Subscribe to never miss a beat.

Queryable Executables

fzakaria.com

August 26, 2026

7 min read

🔥🔥🔥🔥🔥

62/100

Summary

SELF is an executable format that stores a program as a SQLite database, with executable segments represented as database rows. A Linux binfmt_misc interpreter maps those rows and transfers control to the program entry point, allowing executable contents and related metadata to be queried with SQL. The format can also let a running program open its own SQLite file through argv[0] and persist state in that same file; /proc/self/exe does not currently provide the original file in this setup. The self-httpd proof of concept packages a web server, website routes, visitor logs and button-press records into one SQLite database file. Its routes, visits and presses tables store page content and runtime data, while the server can query its own segments, symbols and relocations. A POST request to its /api/press endpoint inserts a button press into the executable’s database, and the live demonstration is hosted at selfdb.exe.xyz. SQLite transactions allow site content in the running file to be updated or rolled back without restarting the server. SQLite tools such as sqldiff can compare code, route and metadata changes between versions, and FTS5 can index pages stored in the executable. Deployments can copy a single file, while SQL INSERT ... SELECT statements can migrate tables such as visitor logs and button presses from an old file to a new build before it is swapped in.

Key Takeaways

SELF represents executable code and metadata as tables in a SQLite database and uses a binfmt_misc interpreter to execute it.
The self-httpd prototype stores its server program, web routes, visitor logs and application state in one SQLite database file.
A SELF program can use argv[0] to reopen its own executable database and persist writes across invocations.
SQLite transactions can update a running self-httpd site’s content in place, and SQLite tools can diff or full-text-index data within the executable.
A new SELF deployment can preserve selected runtime data by copying it from the old database file with SQL before replacing the executable.

What the discussion said

AI was a side thread rather than the main subject. Most commenters debated the executable/database design itself, but the AI-adjacent remarks latched onto an intriguing future use: a self-contained, mutable program file could potentially carry a personalized, continually trained local model along with its specialized knowledge. Several readers saw that as a natural package for an agent or AI harness, where code, state, and learned behavior travel together instead of being split across an application install and external data stores. The enthusiasm was deliberately speculative. It depended on consumer hardware eventually making inexpensive local inference and continual learning practical; nobody claimed the format solves those hard model problems today. The only clear pushback was cultural and credibility-focused: one reader lamented that AI discussion is displacing stranger systems ideas, while another dismissed an associated language-and-database project as likely AI-generated filler absent stronger proof. There was no substantive argument over model quality, training methods, benchmarks, or safety. The narrow AI consensus is that the format is an imaginative potential vessel for portable, personalized agents, not an AI breakthrough by itself.

Read original article

Community Sentiment

Mixed

Positives

A self-contained executable that carries its own mutable state could become a compelling distribution format for personalized local models, preserving specialized expertise wherever the program travels.
Commenters can see AI agents benefiting from a single transactional bundle of code, data, and evolving state, rather than relying on a scattered runtime environment.

Concerns

The envisioned personal-model use case rests on still-unmet conditions: cheap consumer inference and efficient continuous learning, so it remains a provocative future scenario rather than a present capability.
One associated database-and-language claim drew skepticism as possible AI-generated filler, signaling that flashy AI-adjacent projects need credible technical substance to earn trust.