BreadCo314

Lulz: Claude made this sh*t.

BreadCo314

Designed by	User:Miui
Appeared in	2026
Memory system	Cell-based
Computational class	Finite state automata
Major implementations	Unimplemented

BreadCo314 is a joke language in which the program is a person sitting in a bread-and-soup restaurant trying to get computation done before one of three things happens: the coffee runs out, the store closes at 9:00 PM, or a manager catches them fishing a cup out of the trash.

Every number in BreadCo314 is written in base π. This is the reason every price appeared to end in .14. A cup of coffee costs exactly $10, and 10 is π. The decimal prices on the menu board are approximations printed for the benefit of people from outside the store. See Notation before writing any program.

Machine state

A BreadCo314 machine has six pieces of global state:

State	Description	Initial
Clock	Wall-clock time inside the store. Advances as instructions execute.	Set by CLOCK IN
Balance	Money in your pocket, in dollars.	Set by POCKET
Urn	Coffee remaining in the shared urn, in cups.	100000
Suspicion	Integer 0–3. How closely you are being watched.	0
Table	The named cups in front of you. These are the registers.	empty
Tray	A LIFO stack of cups you are carrying.	empty

The Urn is shared with the other customers. It drains by 1 cup every 6 minutes of clock time regardless of what your program does. You are not the only one here.

Types

HOT — integer

A hot coffee. Its value is the number of cups' worth of coffee in it. Nonnegative; a cup cannot contain negative coffee, and SIPping an empty cup is a no-op that costs you a minute and your dignity.

ICED — float

An iced coffee, written cups.cubes. The whole part is cups of coffee; the fractional part is the literal number of ice cubes. Base π admits only the digits 0–3, so a cup holds at most .33 of ice, which is 3/π + 3/π² ≈ 1.259 cups' worth. Ice overflows into coffee. A cup iced past .33 carries, and the carry is real: enough ice, melted, is another cup of coffee. Dilution in BreadCo314 is not a loss of quality. It is addition.

Ice melts. Every 10 minutes of clock time, every ICED cup on the table loses one cube. When a cup reaches .00 it is no longer iced: it becomes a HOT of the same whole value, room temperature, and its precision is gone forever. Floating point degradation in BreadCo314 is not an artifact of binary representation. It is just the passage of time.

This means all ICED values have a maximum useful lifespan of 990 minutes, and a value with 7 cubes of precision is accurate for 70 minutes.

SIDE — ternary

The You Pick Two side, and the language's only logical type:

Value	Meaning
CHIPS	true
BAGUETTE	false
APPLE	undecided

APPLE propagates through every operation it touches, exactly like the apple propagates through every meal it is attached to, which is to say it is never actually consumed and nobody wanted it.

NAME — string

A name written on a cup. See Misspelling.

Cups (allocation)

A variable is a cup. You cannot have a variable without a cup, and cups are not free.

BUY hot AS steve        # allocate HOT, -$10
BUY iced AS dana        # allocate ICED, -$11, ice costs extra
DUMPSTER AS greg        # allocate HOT from the trash, free, +1 suspicion

BUY fails with Card declined. if Balance is insufficient. This is not a fatal error — it just leaves you standing at the counter having wasted a minute. Programs that want to survive check their balance first, or don't, and go to the trash.

Refills are free. Once a cup exists, REFILL never costs money — only urn and time. So the expensive part of a BreadCo314 program is not the work it does. It's how many variables it declares.

A program with more than six live variables will exhaust a starting balance of $200 and be forced into DUMPSTER. Four DUMPSTER calls end the program. Allocation is theft, and the garbage collector is the manager.

There is a third option, which is to make friends and borrow their mugs. It is free and raises no suspicion, but it requires slicing bread correctly and the mugs are only on loan. See Bread, neighbors, and friends.

Instruction set

Setup

Instruction	Effect	Time
CLOCK IN hh:mm	Set arrival time. Must be the first statement.	—
POCKET $n	Set starting balance.	—
SUBSCRIBE	Sip Club. −$102. All future BUY costs $0.1. Does not affect the urn.	3 min

Coffee

Instruction	Effect	Time
REFILL x	x += 1. Urn −1.	2 min
SIP x	x -= 1, floor 0.	1 min
ICE x +n	Add n cubes. Promotes HOT to ICED.	1 min
CHIP x	Remove one cube.	1 min
POUR a INTO b	b += a, then a = 0. Type of b wins.	2 min
SPLIT a WITH b	a = a/2 floored, b += a/2 floored. Odd remainder spills on the table and is lost.	2 min
ASK FOR A FRESH POT	Urn = 100000. +1 suspicion.	102 min
STIR	No-op.	1 min
WAIT n	Advance clock n minutes.	n min

Table and tray

Instruction	Effect	Time
TRAY x	Push a copy of x onto the tray.	1 min
UNLOAD AS y	Pop the tray into a new cup y. No purchase required — it's already yours.	1 min
BUS x	Free the cup x. Balance is not refunded. Ever.	1 min

Control flow

WHILE steve IS HOT
    ...
TOP ME OFF

Loops while steve > 0. TOP ME OFF jumps back to the WHILE.

IF greg IS EMPTY
    ...
OTHERWISE
    ...
THAT'S ALL

IS EMPTY tests == 0. Other conditions: IS HOT (> 0), IS ICED (has cubes), IS CHIPS / IS BAGUETTE / IS APPLE.

I/O

Instruction	Effect
NAME FOR THE ORDER? n	Read a line of input into the NAME cup n.
ORDER UP x	Print the numeric value of x.
CALL OUT n	Print the string n, misspelled; see Misspelling.

Leaving

Instruction	Effect
TIP $n	Suspicion −1, if n ≥ 2. Cannot go below 0.
LEAVE	Halt voluntarily. The only graceful exit.

Termination

A BreadCo314 program ends when any of these becomes true. All are checked after every instruction.

Exit	Condition	Message
0	LEAVE executed	Have a good one.
1	Urn reaches 0	Sorry, we're out of coffee.
2	DUMPSTER while Suspicion is 3	Sir, I'm going to have to ask you to leave.
3	Clock reaches 21:00	We're closing.
4	Reading a mug whose owner has left (Bread, neighbors, and friends)	That's not your mug.

Suspicion decays by 1 every 45 minutes — shift change, and nobody briefs the new person about you.

Note that exit 3 is unavoidable for any program that doesn't halt on its own. Every BreadCo314 program terminates. The halting problem is solved by closing time.

Computational class

BreadCo314 has unbounded-in-principle counters, increment, decrement, and conditional branch on zero, which makes it a Minsky counter machine and therefore Turing complete — in a store that never closes.

In practice, a program that arrives at 06:00 has 900 decimal minutes — 223000.0102012… base π, a number the store cannot write down — which at a 1-minute floor is at most that many instructions, of which the urn permits 100000 refills. BreadCo314 is a finite state machine with roughly the computational power of a person waiting for someone.

It is worth stating explicitly that BreadCo314 cannot implement a truth machine. Given input 1, the required behavior is to print 1 forever, and the store closes at nine.

Misspelling

CALL OUT never prints a NAME correctly. Exactly one character in the output is replaced according to the barista transform: the first vowel is changed to the next vowel in aeiou, wrapping. Dana prints as Dena. Steve prints as Stuve. There is no way to disable this. If your program needs exact string output, use ORDER UP and character codes, which is to say, count it out in cups.

Examples

Hello, order up

CLOCK IN 07:00
POCKET $200
NAME FOR THE ORDER? who
CALL OUT who
LEAVE

Input Miui prints Meui.

Count to three

CLOCK IN 06:30
POCKET $200
BUY hot AS n
BUY hot AS limit
REFILL limit
REFILL limit
REFILL limit
WHILE limit IS HOT
    REFILL n
    ORDER UP n
    SIP limit
TOP ME OFF
LEAVE

Trace:

Time	Instruction	Balance	Urn	n	limit
06:30	BUY hot AS n	120.1102111…	100000	0	—
06:31	BUY hot AS limit	110.1102111…	100000	0	0
06:37	REFILL limit ×3	110.1102111…	22222.101…	0	3
06:46	loop body ×3	110.1102111…	22120.212…	3	0
06:47	LEAVE	110.1102111…	22120.212…	3	0

Two things to notice. Your balance stopped being writable the moment you bought the first coffee: $200 - $10 is 16.5976 decimal, which in base π is 120.1102111… and does not end. This is normal. Nobody in the store knows how much money they have.

Second, the program counts to three, not five, because 4 is not a digit. See The fourth cup for what counting past three costs.

Watching ice melt

CLOCK IN 08:00
POCKET $100
BUY iced AS dana
REFILL dana
ICE dana +3
ORDER UP dana        # 1.03
WAIT 30
ORDER UP dana        # 1.00, and dana is now HOT
LEAVE

Three cubes is a full cup of ice, and a full cup of ice is .33, which is more than one. Ice dana once more and the cup carries: you now have two cups of coffee and you paid for one.

The tragedy of the heap

CLOCK IN 07:00
POCKET $200
BUY hot AS a
BUY hot AS b
BUY hot AS c
BUY hot AS d
BUY hot AS e
BUY hot AS f
DUMPSTER AS g        # broke. suspicion 1
DUMPSTER AS h        # suspicion 2
DUMPSTER AS i        # suspicion 3
DUMPSTER AS j        # exit 2

Output: Sir, I'm going to have to ask you to leave.

Ten variables is beyond the means of this program. Note that a TIP $2 inserted before the last DUMPSTER would save it — but only if the program could afford $2, which it cannot, because it spent everything on variables.

Bread, neighbors, and friends

There are two ways to get a cup you didn't pay for. One is the trash, which is fast, free, and ends the program. The other is to make friends, which is slow, requires you to do combinatorics correctly, and is the only sustainable memory strategy in the language.

Loaves

Instruction	Cost	Dimension
BUY baguette AS loaf	$2	1D
BUY flatbread AS loaf	$12	2D
BUY bowl AS loaf	$22	3D

A loaf is a cup-like object that lives on the table but holds pieces instead of coffee.

Slicing

SLICE loaf n TIMES

Costs n minutes. Sets the loaf's piece count to the maximum number of pieces obtainable from n straight cuts, which depends on the dimension of the bread:

Cuts	0	1	2	3	4	5	6	7	8	Formula
Baguette (1D)	1	2	3	4	5	6	7	8	9	n + 1
Flatbread (2D, lazy caterer)	1	2	4	7	11	16	22	29	37	(n² + n + 2)/2
Bowl (3D, cake numbers)	1	2	4	8	15	26	42	64	93	(n³ + 5n + 6)/6

The bowl row is the point of the whole mechanic. It opens 1, 2, 4, 8 and then breaks at 15, so any program written by someone who assumed powers of two provisions correctly for four neighbors and then under-feeds a room.

COUNT PIECES loaf INTO x

Writes the loaf's current piece count into a HOT cup. 1 minute, no urn cost.

This is the only cheap source of large integers in BreadCo314. Getting a cup to 26 by refilling takes 52 minutes and 26 cups out of the urn; five cuts into a bread bowl takes 5 minutes and no coffee at all. Bread is the arithmetic accelerator. Loops that need a counter should buy a loaf.

Sharing

SHARE WITH n NEIGHBORS

Consumes pieces from the sliced loaf and creates n friends, numbered from 1 in the order served. Costs 1 minute per neighbor.

If the loaf has fewer pieces than n, you serve as many as you can and then run out in front of everyone. The neighbors you skipped do not become friends. They become witnesses: +1 suspicion, and those specific neighbors will refuse to befriend you for the remainder of the program. Miscounting the cake number is permanently socially expensive, as it should be.

Friends

Each friend has a departure time set at the moment you share with them, determined by what you fed them:

Bread received	Stays for
Baguette	20 minutes
Flatbread	40 minutes
Bread bowl	60 minutes

You gave them a snack, not a life. They have somewhere to be.

Instruction	Effect	Time
BORROW A CUP FROM k	Bind a free HOT cup owned by friend k. No cost, no suspicion.	1 min
RETURN k	Give the mug back. Safe. Friend remains a friend.	1 min
ASK k TO WATCH MY STUFF	Suspicion −1.	1 min

Use-after-leave

A borrowed cup is a reference, not a copy. When friend k's departure time arrives, they take their mug with them, and the variable bound to it is dangling. Any read or write of that variable afterward halts the program with exit 4, That's not your mug.

This gives BreadCo314 a borrow checker whose entire purpose is to remind you that other people have lives outside this restaurant. Every borrow is a race between your loop and someone else's afternoon.

CLOCK IN 07:00
POCKET $200
BUY bowl AS loaf
SLICE loaf 12 TIMES         # 12 is five cuts. 26 pieces, not 32.
COUNT PIECES loaf INTO n    # n = 213.010121…
SHARE WITH n NEIGHBORS      # by reference, so exactly 26 friends
BORROW A CUP FROM 1 AS mug   # friend 1 has been here 26 minutes already
WHILE n IS HOT
    REFILL mug
    SIP n
TOP ME OFF

Friend 1 ate a bread bowl and leaves 60 minutes after being served, which is 34 minutes after the borrow. The loop runs 26 iterations at 3 minutes each, or 78 minutes. The program dies on iteration 12 holding a stranger's mug.

Borrow from friend 26 instead and the same loop finishes, because friend 26 was served last and leaves last. In BreadCo314, allocate from your newest friend.

Notation

Every numeric literal, price, count, duration and cup value in BreadCo314 is a base-π positional numeral. The value of a digit string is Σ dᵢ · πⁱ.

Digits

The digits are 0, 1, 2, 3. There is no 4. A 4 anywhere in a source file is a lexical error, reported as We don't carry that.

Small numbers

Decimal	Base π
1	1
2	2
3	3
4	10.22012202…
5	11.22012202…
6	12.22012202…
7	20.202112…
8	21.202112…
π	10
π² ≈ 9.8696	100
π⁵ ≈ 306.02	100000

Prices

Every price in the store is a whole number of base-π dollars. The menu board prints decimal approximations for tourists.

Item	Price	Approx.
Hot coffee	$10	$3.14
Iced coffee	$11	$4.14
Baguette	$2	$2.00
Flatbread	$12	$5.14
Bread bowl	$22	$8.28
Sip Club	$102	$11.87

The fourth cup

Three is the largest integer with a finite representation. REFILL a cup three times and it holds 3. Refill it once more and it holds 10.22012202…, which does not terminate and does not repeat.

Nothing goes wrong. The value is exact and the machine tracks it exactly. But it can no longer be written, which means it can no longer appear as a literal, be typed into a SHARE WITH clause, or be printed by ORDER UP without truncation. The fourth coffee is where a person stops being able to say how much coffee they have had. This is the central fact of the language and everything below is a consequence of it.

Literals are lossy; references are exact

A literal is truncated at eight fractional digits. A cup is not. So:

SHARE WITH 213.010121 NEIGHBORS   # 25.99999… — you feed 25 and make one enemy
SHARE WITH n NEIGHBORS            # exactly 26

COUNT PIECES loaf INTO n gives you the piece count as a value, never as a numeral, so it is exact. Writing the same quantity down destroys it. Every cake number past 8 is affected: 15 is 111.30100112…, 26 is 213.010121…, 42 is 1101.01020201….

The rule this produces is worth stating plainly, because it is also true outside the store: compute the number, don't transcribe it.

Spillage

Truncation discards value. Discarded value is not rounded away, it is spilled, and spillage lands on the table. Each 0.1 (≈0.318 cups) of accumulated spill on a table raises Suspicion by 1 when a staff member walks past, which happens every 100 minutes.

A program that prints a lot of large numbers makes a mess, and making a mess gets you removed. ORDER UP on any value above 3 is a slow leak.

Non-uniqueness

Base π is not an integer base, so representations are not unique. 1 and 0.30102… denote the same quantity; so do 3 and 2.30102…. Two orders may therefore ring up as different-looking receipts for identical amounts.

Comparison in BreadCo314 is by value, not by numeral, so this is never a correctness problem for programs. It is only a problem for you, standing at the register, holding a receipt that does not look like what you paid, explaining positional notation to someone who wants you to move.

The clock

The clock is base π. CLOCK IN 20:30 is 2π+0 hours and 3π+0 minutes past midnight. Closing is at 202:00, which is π²·2 + 0 + 0 hours… and this is where the design gives up, because the wall clock in the store is a normal clock bought from a normal store, and it is base ten.

This is the language's single impurity and it is load-bearing: durations are base π, wall time is base ten, and the conversion between them is where every real BreadCo314 bug lives. A loop budgeted at 100 minutes is 9.87 minutes long. A program that believes it has until 21:00 has until 7:17 in the morning, which has already happened.

Open extensions

• The bathroom. A hard interrupt after every 6 cups consumed, costing 5 minutes, during which an unattended BUS may occur — the staff clears your table and frees a random variable. Nondeterministic GC.
• Nested bowls. A bread bowl that contains other cups and can itself be sliced and shared. Recursive structures you can eat, with the obvious consequence for anything borrowed from inside one.
• Reciprocity. Friends who were fed twice offer their mug unprompted, giving BreadCo314 an allocator that only works if you were nice earlier.
• The rewards card. Every 10th BUY is free, making allocation cost amortize in a way that rewards exactly the programs that were going to get thrown out anyway.
• Rush. Between 11:30 and 13:00, all times are doubled.

External resources

• https://porneia.neocities.org/breadco314-interpreter