fount ships one agent runtime across Rust, .NET, Swift, Gradle, sbt and Elixir

The quick start installs a package the root manifest does not publish

`npx the-fount` is the entire quick start, and the package behind that name is not the package at the repository root. The root manifest is named `fount`, its version is the literal string `dev`, and it describes a framework rather than an application:

{
	"name": "fount",
	"version": "dev",
	"bin": {
		"fount": "path/fount.mjs"
	},
	"exports": {
		"./*": "./src/*"
	}
}

That is a library shape: everything under `src` is importable through the exports map, and the one executable it declares is the `fount` bin pointing at `path/fount.mjs`. The publish entry does not publish from the root either:

"publish": "cd ./src/runner/npm && npm publish"

So the CLI behind the quick start is packaged under `src/runner/npm`, and the root manifest stays at `dev`. Versions then run in three tracks at once: `dev` in package.json, `0.0.0` in Cargo.toml, and release tags called `runner-v0.0.0.4`, `runner-v0.0.0.5` and `runner-v0.0.0.6`, the newest published on September 29, 2026.

Seven build systems and three task runners share one root

The top level listing holds a manifest for nearly every toolchain in wide use: Cargo.toml and Cargo.lock for Rust, Directory.Build.props next to fount.csproj for .NET, Package.swift for Swift, build.gradle with settings.gradle and gradlew for Gradle, build.sbt for sbt, mix.exs for Elixir, deno.json for Deno, package.json for npm, and gulpfile.mjs for Gulp. On top of those sit three separate task runners, Makefile, Justfile and Taskfile.yml, which means three unrelated places to define what clean or build means. Four launchers for the same program sit beside them: `run`, `run.bat`, `run.cmd` and `run.sh`. The listing also carries a `desktop.ini` in a repository root, a typos.toml spelling checker, an eslint.config.mjs, a .coderabbit.yaml, and directories named `.agents` and `.esh` next to `default`, `path`, `src`, `docs` and `imgs`. A part author has to work out which of those build systems owns the file being edited, and the only mapping stated outright is the Rust one.

The Rust entry point sits inside a directory called polyglot

The Cargo manifest names one binary and pins the toolchain with two attributes:

[package]
name = "fount"
version = "0.0.0"
edition = "2024"
rust-version = "1.85.0"

[[bin]]
name = "fount"
path = "src/runner/polyglot/cargo/main.rs"

Three things follow. The crate version is a literal `0.0.0`, so the Rust side carries no release numbering of its own while the published tags walk from `runner-v0.0.0.4` to `.6`. The entry point is `src/runner/polyglot/cargo/main.rs`, which places Rust inside a directory called polyglot, right next to the npm runner that `npx the-fount` executes. And edition 2024 with `rust-version = 1.85.0` sets a floor that older stable toolchains cannot clear, while the visible setup steps go through npx without naming a Rust toolchain anywhere.

Eleven verbs run through one script, and update runs git

Every command in fount funnels through a single file. The scripts block calls `node path/fount.mjs` with a different final argument for each verb: `run`, `init`, `debug`, `shutdown`, `reboot`, `clean`, `geneexe`, `remove`, `nop` and `log`. A second set of friendlier names points at the same file: `start`, `stop`, `restart`, `dev` and `uninstall`. Two of the verbs, `geneexe` and `nop`, appear in no other form in the visible documentation. The update entry is the one that behaves differently:

"update": "git pull --rebase origin master"

That reaches for a git working copy on the master branch, which is the branch the repository actually uses. It fits a clone of the repository and cannot work in an npm install, where there is no `.git` directory to pull into and no remote to rebase from. The same verb therefore means two different things depending on how the program arrived, and anyone who installed through npx has no update path in the manifest at all.

Agent sent code blocks run live, and the README warns about the parts

The two most informative paragraphs sit next to each other in the source. One says the code blocks an agent sends are live rather than text: real-time compilation and running for C, C++, Rust, Python and JavaScript, with stdout on screen and, for compiled languages, the ASM disassembly shown too. The other is the Why not fount list, which says the learning curve is steeper, code knowledge is needed, and some community parts may contain malicious code, with the instruction to judge and choose carefully. Together they are the whole risk profile: parts execute on the host, and parts arrive from other people. The rest of the page builds on the same idea that code is the product. Everything is a file, logic is driven by code, dragging a conversation bubble onto a folder produces a standalone HTML report, and dragging a character onto the desktop exports it as a shareable file.

Peer chat by invitation link, Bluetooth, and a transport list that stops mid-word

Peer connections are described as native and encrypted, joined through an invitation link on the same LAN, with oversized file transfer and no relay server in the path. Bluetooth is offered for the case where no router is involved, and the P2P layer is described as replaceable to support LoRa, NFC, infrared, USB and further transports. The sentence listing them ends mid-word at `custom data exchange prot`. Alongside that sit the social claims: chat with other fount users, file sharing of any size, likes, custom emojis, no moderation, no ban risk and no subscriptions. The package keywords agree with the transport story, listing `p2p-chat`, `bluetooth-le` and `nostr` in the same array as `characterai`, `sillytavern` and `telegram-bot`. Read together, no moderation and untrusted community parts are the two ends of one trust boundary, and the project states both without connecting them.

The compose file writes generated dependencies into the host node_modules

The compose file publishes two ports and mounts two host directories:

services:
  fount:
    container_name: fount
    image: steve02081504/fount:latest
    ports:
      - '8931:8931'
      - '16698:16698'
    volumes:
      - ./data:/app/data:rw
      - ./node_modules:/app/node_modules:rw
    restart: unless-stopped

Neither 8931 nor 16698 is given a purpose in the visible setup steps, and the `latest` tag means the file does not pin the version the release tags describe. The second volume is the one to think about: the container writes the dependencies your parts generate back into the host's `./node_modules`, so what lands there are host files with host permissions, created by code that arrived over the network. The environment template lists what the runtime reads, ending with `GH_TOKEN` under a comment saying it is auto used when a deno panic is detected in the fount test, next to `FOUNT_API_KEY`, `OPENAI_BASE_URL`, `GEMINI_BASE_URL`, `HF_HOME` and `MSYS_ROOT_PATH`.

The README names six products it would rather you used

A block at the top of the source points readers elsewhere, which is unusual and useful. Use OpenClaw when you want to try agents without deep customisation or efficiency tuning; ChatGPT when you just want to chat and do not mind cloud history with no export or migration, and do not mind ads; character.ai for a character without agent features, where subscription costs and not configuring software are acceptable; Discord if you are fine with the risk of being banned and tolerate upload size limits and ads; SillyTavern when something needs STscript or its plugins; SSP for desktop pets that do not have to use AI at all. The project page description is a line of dialogue rather than a summary of the software, nineteen translated READMEs sit under `docs/readme`, a community tutorial is linked in Chinese, and deepwiki is named for code questions. The license field in the repository metadata reads NOASSERTION while a LICENSE file sits at the root, so the terms are not settled by the project page.

Editorial conclusion

fount is a parts runtime for people who already write code, and it says so itself: steeper learning curve, code knowledge needed, and community parts that may contain malicious code. That shape fits the design, since the parts execute code on the host and the transport layer reaches outside the LAN. The friction is in the packaging, not the idea. The command you start with installs something the repository root does not publish, updates are wired to git, the compose file pins `latest` and writes generated dependencies back into the host `node_modules`, and the peer chat is described as having no moderation at all, on the same trust boundary as untrusted code. Before adopting it: build the runner with Rust 1.85 or newer, work out what the two published ports are for, and decide in advance which parts you are willing to let execute on your machine. The last commit on master is dated October 1, 2026, and the newest release tag is runner-v0.0.0.6 from September 29, 2026.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. steve02081504/fount on GitHub