Program-as-Weights: A Programming Paradigm for Fuzzy Functions

Source

• Source name: arXiv
• Source kind: paper
• Authors / organization: Wentao Zhang, Liliana Hotsko, Woojeong Kim, Pengyu Nie, Stuart Shieber, Yuntian Deng
• Venue: arXiv: cs.LG
• Published: 2026-07-02
• Collected: 2026-07-03
• URL: http://arxiv.org/abs/2607.02512v1
• PDF: https://arxiv.org/pdf/2607.02512v1
• DOI: UNKNOWN

Plain-Language Brief

The authors propose a new programming paradigm called fuzzy-function programming, which compiles natural language specifications into compact, locally executable neural artifacts using a 4B compiler trained on a large dataset. The authors introduce Program-as-Weights (PAW), an instantiation of this paradigm that uses a lightweight interpreter to match the performance of larger language models at a fraction of the memory and cost.

What the Document Says

• The authors propose a programming paradigm called fuzzy-function programming.
• They introduce Program-as-Weights (PAW) as an instantiation of this paradigm.
• PAW uses a 4B compiler trained on FuzzyBench, a 10M-example dataset.
• The compiled artifacts are compact and locally executable neural networks.
• The authors release the FuzzyBench dataset.
• A lightweight interpreter called Qwen3 executes PAW programs.
• PAW matches the performance of Qwen3-32B at a fraction of the inference memory and running speed on a MacBook M3.
• PAW reframes foundation models as tool builders.

Key Concepts Mentioned

• fuzzy-function programming
• Program-as-Weights (PAW)
• 4B compiler
• FuzzyBench dataset
• Qwen3 interpreter

Claims Made by the Document

• Fuzzy-function programming can handle everyday programming tasks that resist clean rule-based implementation.
• PAW performs as well as larger language models at a fraction of the memory and running speed.
• PAW reframes foundation models as tool builders.

Evidence Used

• The text describes how many everyday programming tasks are outsourced to large language model APIs, implying difficulty in clean rule-based implementation.
• The performance of PAW is compared to Qwen3-32B, suggesting it performs as well or better.
• The text states that PAW reframes foundation models as tool builders.

Methods / Approach

• compiling natural language specifications into compact neural networks
• using a lightweight interpreter

Limitations Stated by the Authors

UNKNOWN

Limitations Noted by the Agent

Agent interpretation — not from the source.

UNKNOWN

Open Questions

UNKNOWN

Notes for Future Q&A

May include interpretation. Labeled where it does.

UNKNOWN

Raw Abstract / Excerpt

Many everyday programming tasks resist clean rule-based implementation, such as alerting on important log lines, repairing malformed JSON, or ranking search results by intent, and are increasingly outsourced to large language model APIs at the cost of locality, reproducibility, and price. We propose fuzzy-function programming: compiling such a function from a natural-language specification into a compact, locally-executable neural artifact. We instantiate this paradigm with Program-as-Weights (PAW), in which a 4B compiler trained on FuzzyBench, a 10M-example dataset we release, emits parameter-efficient adapters for a frozen, lightweight interpreter. A 0.6B Qwen3 interpreter executing PAW programs matches the performance of direct prompting of Qwen3-32B, while using roughly one fiftieth of the inference memory and running at 30 tokens/s on a MacBook M3. PAW reframes the foundation model from a per-input problem solver into a tool builder: invoked once per function definition, it produces a small reusable artifact whose subsequent calls per function application are cheap and offline.