A systems programming language

Meet Phil.

Build systems that
keep their promises.

Catch mistakes where software parts meet. Phil makes the rules about data, permissions, and communication explicit, so developers can check them.

Open source. In active development.
See where things stand.

Phil, a friendly charcoal and cream border collie with soft brown eyes and a relaxed smile

Why Phil?

The parts work.
Does the system?

Phil is for developers building systems where a mistake between components matters—saving the wrong data, allowing too much access, or replacing a component that no longer keeps its promises.

Phil lets developers describe those handoffs as rules the tools can check: who can use the data, which messages can happen next, and what a replacement component must guarantee.

  1. 01Get the right data back.Phil’s storage example checks retrieved bytes against their expected digital fingerprint.
  2. 02Give each part less power.Make permissions explicit, so an interface meant for reading cannot silently add permission to write.
  3. 03Change a part with confidence.A replacement storage provider must meet the public obligations of the part it replaces.

What makes it different

The agreements belong
in the program.

Phil brings rules about communication, permissions, and replaceable parts into the language itself. Developers can inspect which obligations have evidence and which still need work, alongside the tests they already write.

Where to start: explore storage, file-transfer, and cooperating-service designs where those boundaries matter. Phil is still under development; its current examples demonstrate specific checked pieces, not a finished solution for every application.

Follow a file through the storage example
See how the rules work

Small examples. Useful ideas.

Make the rules
part of the program.

A rule might say “borrow this data,” “send this message next,” or “allow reading, but not writing.” Here’s how those ideas appear in Phil.

SteveGetCLI / source excerpt
// Inspect the bytes through a borrowed view.
let digestDecision = borrow bytes as bytesView {
    digest_check(contentId, bytesView)
}

Let another part take a look.

Checking some data doesn’t have to mean taking ownership of it. Here, the checking function borrows access to the bytes—the data—while the owner stays responsible for them.

Read the ownership details

This excerpt uses a scoped borrow in SteveGetCLI’s digest check. The full source shows the surrounding resource handling and release. The comment above the excerpt is explanatory; it is not compiler output.

Inspect the complete source

The bigger picture

Put your architecture
to work.

Phil describes a system’s participants, their boundaries, and how they’re allowed to communicate.

Those relationships belong in the program, where they can be inspected and checked.

Explore architectures

The architecture names the participants.
The implementation chooses how to run them.

Phil the border collie gathering four cheerful sheep marked with hexadecimal values
Everyone has a part to play.Illustration by Railee Adams

Room to change your mind

Change the implementation.
Keep the promise.

Your application needs to store data. It shouldn’t have to know every detail of how storage works.

A public contract describes what the storage part must provide. A different implementation can take its place when it meets the required obligations.

See it in the Steve storage example
What makes a replacement valid?

A matching name or interface is not enough. Replacement is subject to the contract’s obligations and the evidence required for that implementation. The tour’s MemoryStore and RemoteStore declarations illustrate different realization choices.

Read the provider declarations and obligations

One boundary. Different implementations.

Your application
Public contractStore

MemoryStore supplies an implementation in Phil source. It still has obligations to meet.

Illustrated from the provider declarations in the tour

The person behind Phil

Meredith
Patterson.

Founder & author of Phil

Meredith Patterson is a programmer and security researcher, and one of the founders of language-theoretic security.

Her research examines how precisely defined languages can help software handle input safely. With Phil, she is building a systems language that makes architecture, communication, permissions, and proof obligations part of the program.

Trust has a paper trail

Follow the evidence.

See what was checked, which implementation it applies to, and which assumptions it relies on.

Phil is under active development. The repository documents the checked pieces and the work still ahead.

The verification map

Follow a claim.
Find its evidence.

See what each claim depends on, which proof files it cites, and where work is still open.

Explore the full map 250 claims 18 connected communities
Architecture / sourceSelect a card
Depends on
Cites
01 / The claimRepeated instances stay distinct. Explicit references share an existing instance.
For a closer technical reading

The Phase 1 grammar defines concrete syntax. The typing and semantics reader’s guide is a non-normative review aid. Accepting syntax, verifying source, and certifying a built artifact are distinct steps.

The accepted design distinguishes intrinsic invalidity from residual proof, runtime, assumption, and export obligations. Verification and realization integration, portable handoff artifacts, and full ordinary-source upload/Steve exit witnesses remain in progress.

A little background

What is
LangSec?

Language-theoretic security.

Where LangSec meets Phil.

LangSec starts with the language of an input: define which forms are valid, and recognize them before the rest of a program acts on them.

Phil source code is an input language too. Its grammar describes how a program can be written; parsing checks that the code follows that grammar.

Phil’s checks for types, ownership, protocols, and obligations go further. Parsing is the starting point—it does not establish that a program’s behavior has been verified.

A good place to begin

Try the rules for yourself.

Start with an idea. Read a little code. Follow your curiosity.

Made around Phil

A community of curious builders.

Independent tools give you more ways to explore the language.

Built independently by the Phil Tools community. Execution modes and language coverage vary by tool.

Small start. Clear intentions.

Let’s build something
that keeps its promises.

Start with the tour
Phil with both ears perked and a friendly, attentive expression