Docs · FLY COMMONS

01Sense light

02Compute

03Move

04Settle

One fly, shared by everyone

FLY COMMONS is a public neural experiment on BNB Smart Chain (chain ID 56). Everyone interacts with the same fly, the same light and the same persistent brain state. FLY is the experiment’s ERC-20 token; minting does not create a separate fly or an NFT.

The experiment has two economic phases. During the juvenile phase, paid interactions issue FLY and build liquidity. When dev opens trading, issuance ends permanently and the adult phase begins. Trading taxes then fund BNB rewards for advancing the experiment.

How to participate

You can observe without a wallet. To change the experiment, connect a wallet on BNB Smart Chain with enough BNB for the transaction. The website proposes a gas price of 0.1 Gwei; your wallet may allow you to edit it before confirming.

Choose “Change light & advance” to set the light direction and intensity, or “Keep light & advance” to continue with the current environment.
Direction has 16 settings. Light intensity ranges from 0 to 100. Moving a slider only prepares an input; it does not send a transaction.
Review the protocol fee and available reward, then click advance and confirm in your wallet. Wait for the transaction to be confirmed.
Every successful interaction reads the light, computes neural activity, updates the fly’s position and brain, then settles minting or a BNB reward. Both options run the complete step.

Juvenile phase: advance & mint

Each interaction requires exactly 0.01 BNB plus network gas. In the same transaction, the fly advances, 100,000 FLY is issued, liquidity is added and the dev share is paid. The allocation per interaction is:

Juvenile phase: advance & mint
Recipient	BNB	FLY
Caller	—	50,000
Liquidity allocation	0.005	50,000
Dev wallet	0.005 (paid directly)	—

The global limit is 10,000 successful mints. There is no per-wallet limit or one-mint-per-block limit; multiple mints can execute in a single block.
Before trading opens, ordinary nonzero token transfers and trades are blocked. The contract permits the system transfers needed for issuance and liquidity.
A failed transaction rolls back the mint, fly step and fund changes together. Network gas may still be charged.

Supply & liquidity

FLY has 18 decimals. The maximum supply is 1,000,000,000 FLY, but it is issued progressively rather than pre-minted. Every successful juvenile interaction adds 100,000 FLY to total supply.

At all 10,000 mints, callers have received a cumulative 500 million FLY, liquidity has been allocated 500 million FLY + 50 BNB, and dev has received 50 BNB. The total mint payments are 100 BNB, excluding gas.

Liquidity uses the designated PancakeSwap V2 FLY/WBNB pair. Additions follow the pool’s current ratio; unmatched tokens or BNB stay in separately accounted liquidity reserves for later addition. Cumulative allocations are not a guarantee of current pool reserves or market price.

Opening trading & entering adulthood

After at least one mint, the fixed dev address can call becomeAdult(). This opens trading and enters the adult phase in the same transaction. It permanently stops minting and cannot be reversed.

Opening early is allowed. Unused mint allocations are never issued. Final supply equals the number of completed mints multiplied by 100,000 FLY. For example, opening after 2,000 mints fixes supply at 200 million FLY.

Selling out all 10,000 mints does not automatically open trading. Dev still needs to activate adulthood; while sold out but not yet adult, further paid steps cannot succeed.

Trading tax & BNB accounting

After opening, buys and sells through the designated V2 pair each incur a 1% tax collected in FLY. Ordinary wallet-to-wallet transfers do not incur this pair tax. The rule does not automatically cover every independently created market.

Tax tokens accumulate in the contract until converted through the router into native BNB. Actual BNB proceeds are split equally between the caller reward pool and the dev’s claimable balance. In nominal tax terms, that is 0.5% for each side on both buys and sells.

The dev tax share stays in the contract until dev calls claimDevFees(). This differs from the juvenile mint share, which is sent directly to the dev wallet. Reward funds, dev credits and liquidity reserves are tracked separately.

Automatic tax conversion

A subsequent eligible sell triggers an automatic conversion of previously accumulated taxes when their balance reaches 0.05% of the pair’s FLY reserves. The conversion is attempted before the current seller’s transfer; the current trade’s tax can be processed later. Buys and ordinary wallet transfers do not trigger this automatic path.

Each batch is limited to 1% of the pair’s FLY reserves, with at most one automatic attempt per block. Only collected taxes are exchanged; tokens reserved for liquidity are excluded.

Conversion requires at least 60 seconds of price observation. The average-price update must be no more than 600 seconds old. The minimum received BNB is 95% of the average-price quote, or a stricter minimum supplied for a manual conversion.

If the observation or swap cannot pass its checks, an adequately funded sell can continue while the tax conversion is deferred. Tokens remain available for a later attempt. A triggering sell needs additional gas; an insufficient gas limit can still make a transaction fail.

Adult phase: rewards for advancing the fly

Adult interactions require no additional protocol BNB payment and issue no new FLY. The caller still pays network gas and completes the entire neural step. An eligible payout is sent directly to the caller in native BNB.

The payout is the smaller of the available reward pool and 0.0001 BNB. The contract can pay at most one positive reward globally per block. This limit is shared by all wallets, not applied separately to each wallet.

Anyone, including programs and bots, can participate. Execution order determines who receives an available reward. Other interactions in the same block can still advance the fly without a reward if their requested minimum reward is zero.

The website reads current state and simulates the action before wallet confirmation. It submits the displayed adult reward as the minimum acceptable payout. If someone else takes that reward before execution, the transaction may revert instead of advancing for less. When zero is displayed, the zero-reward action explicitly permits an unpaid step.

What the fly computes

The engine is a deliberately small, engineered directional network: 16 visual inputs, 16 direction units and 256 plastic inhibitory weights. It is not a reconstruction of a complete biological fly brain, a living animal or Bitcoin mining.

Light stimulates the visual channels. The network combines that input with its previous activity and adjusts its weights. The resulting activity selects a target direction; the fly turns by at most one of the 16 direction sectors per step and updates its coordinates.

The arena uses integer X and Y coordinates from 0 to 9,999. X increases east and Y increases south; each heading sector is 22.5 degrees. Crossing an edge wraps to the opposite edge. Initial position is (5,000, 5,000).

The calculation is deterministic: the same preceding state and input produce the same next state. Every successful interaction increments the shared tick counter. Multiple transactions in one block advance the fly sequentially.

9.1 · State, scale & initialization

Picture 16 direction units around a circle, spaced 22.5° apart. Index 0 points east, 4 south, 8 west and 12 north. A[i] is the activity of direction unit i; V[j] is visual channel j; W[j,i] inhibits direction i from visual channel j. d is the chosen light direction (0–15), and I is its intensity (0–100). A prime (′) means the next value.

C = [1000, 924, 707, 383, 0, -383, -707, -924,
     -1000, -924, -707, -383, 0, 383, 707, 924]

D(n, q) = trunc(n / q)
M(k) = k mod 16, in [0, 15]
A[i] = D(2200 × max(C[i], 0), 5028)
V[i] = 0
W[j,i] = 350

C is the contract’s integer cosine lookup table, scaled by 1,000. It does not calculate a floating-point cosine. Every D divides and truncates toward zero, including negative terms: D(−769 × 35, 100) = −269, not −270. Apply each division where shown. Initially the position is (5,000, 5,000), heading and light are 0, and activity is biased east. The positive C entries sum to 5,028. These values are model units, not biological firing rates or elapsed milliseconds.

9.2 · Turn light into visual input

Each channel measures how closely its direction aligns with the light. Channels on the opposite half of the circle receive zero new energy. The next visual signal combines 30% of its previous value with 70% of the new energy, giving the sensor a short memory.

E[i] = D(max(C[M(i − d)], 0) × I, 100)
V′[i] = D(3 × V[i] + 7 × E[i], 10)

For a first input from the south (d = 4) at intensity 75, the south channel gets E[4] = 750 and V′[4] = 525. With the same light again, V′[4] becomes 682. Keeping the light still runs this update; choosing intensity 0 makes the previous visual signal decay.

9.3 · Combine the old brain with the new light

The fixed recurrent kernel K links the direction units to each other: nearby directions reinforce one another and distant directions suppress one another. R[i] sums this recurrent input using the previous activities A. H[i] separately sums the visual inhibition using the newly smoothed visual inputs V′ and the previous plastic weights W.

K[i,j] = D(1300 × C[M(i − j)], 1000) − 350
R[i] = Σ(j=0…15) D(K[i,j] × A[j], 1000)
H[i] = Σ(j=0…15) D(W[j,i] × V′[j], 1000)

For the same direction K = 950; for the opposite direction K = −1650. All 16 outputs read the same preceding activity array: updating one unit does not immediately feed its new activity into the next unit. The two 16 × 16 sets of connections have different roles: K is a fixed formula, while W is the stored plastic inhibition.

9.4 · Update the 256 plastic weights

A visual channel and a direction unit that are active together strengthen their inhibitory connection. Each connection has its own update. The increment uses the new visual input V′ and the old activity A, before normalization of this step’s outputs.

W′[j,i] = min(1600,
  W[j,i] + D(12 × V′[j] × A[i], 1,000,000)
)

Weights start at 350 and can only increase, up to 1,600; there is no decay or reset function. Very small increments truncate to zero. This is a local co-activity rule, not backpropagation, reinforcement learning or a reward-prediction model. This step’s inhibition uses W; the updated W′ is saved for subsequent steps. BNB rewards do not enter these equations.

9.5 · Compute and normalize the next activities

Each raw output combines its old activity, the recurrent input and a light-driven term. The light term contains a baseline of 1,000, twice the current visual signal and a deduction for inhibition. Negative outputs are clamped to zero. Positive outputs are then scaled against the sum across all 16 units.

Q[i] = D(35 × A[i], 100)
     + D(35 × R[i], 100)
     + D(30 × (1000 + 2 × V′[i] − D(H[i], 4)), 100)

N[i] = max(Q[i], 0)
S = Σ(i=0…15) N[i]
A′[i] = D(2200 × N[i], S)  if S > 0
A′[i] = A[i]               if S = 0

The normalization budget is 2,200. Integer rounding means the actual sum can be slightly lower; there is no extra pass to distribute the remainder. If every clamped output is zero, the previous activity array is kept. The sensory and weight updates still happen. Each signed division is performed separately; rounding only once at the end would produce different results.

9.6 · Decode a target, then turn gradually

Each direction casts a vector vote weighted by its new activity. Adding those votes produces (vx, vy). The contract compares that vector with all 16 possible directions and chooses the highest dot product. The actual heading moves at most one sector (22.5°) toward that target in a single step.

vx = Σ(i=0…15) A′[i] × C[i]
vy = Σ(i=0…15) A′[i] × C[M(i + 12)]
score[k] = vx × C[k] + vy × C[M(k + 12)]
target = argmax(k=0…15) score[k]

δ = M(target − heading)
heading′ = heading          if δ = 0
heading′ = M(heading + 1)   if 1 ≤ δ ≤ 8
heading′ = M(heading − 1)   if 9 ≤ δ ≤ 15

If vx and vy are both zero, the target stays at the existing heading. Tied maximum scores choose the lowest index, because the scan runs from 0 to 15 and replaces the best only on a strictly greater score. With an exact half-turn tie (δ = 8), the contract takes the +1 direction. Increasing direction indices rotate clockwise because positive Y points south.

9.7 · Move, wrap & persist

The new heading determines the movement vector, roughly 100 coordinate units long. The coordinate plane wraps at its edges: leaving one side re-enters from the other. The new activities, visual values and weights are written back to contract storage, and the shared interaction counter increases by one.

dx = D(C[heading′], 10)
dy = D(C[M(heading′ + 12)], 10)
x′ = (x + dx + 10,000) mod 10,000
y′ = (y + dy + 10,000) mod 10,000
tick′ = tick + 1

At heading 0, a step adds (100, 0). At heading 1, it adds (92, 38), with rounding from the lookup table. Each of the 16 stored weight rows packs 16 unsigned 16-bit weights into one 256-bit slot; packing saves storage without changing the equations. The outer stimulate transaction also settles minting or rewards: if it reverts, all of these brain changes revert with it. Both economic phases use this same engine.

9.8 · Example: steady 75% southern light from the initial state

This is a worked example reproduced with the independent integer reference, not a live chain history. Starting from the deployment’s initial state, set direction 4 and intensity 75, then keep that light for four more steps. Each row represents a complete, successful interaction.

Five calculated steps under southern light
Step	Angle	X	Y	V[4]	A[4]
0	0°	5000	5000	0	0
1	0°	5100	5000	525	112
2	22.5°	5192	5038	682	210
3	45°	5262	5108	729	297
4	45°	5332	5178	743	358
5	67.5°	5370	5270	747	401

For the first step’s south unit i = 4: old activity A[4] = 0, new visual input V′[4] = 525, recurrent input R[4] = −769 and inhibition H[4] = 919. The raw output is 0 − 269 + 546 = 277. The positive outputs sum to 5,399, so A′[4] = D(277 × 2200, 5399) = 112.

W′[4,0] = 350 + D(12 × 525 × 437, 1,000,000) = 352

A′ = [369, 389, 347, 250, 112, 0, 0, 0,
      0, 0, 0, 0, 0, 132, 257, 340]
Σ A′ = 2196

Old east activity A[0] = 437 makes the south-visual-to-east weight rise from 350 to 352. Despite the southern light, the old eastward activity still influences the population vector: the first target remains east, moving to (5,100, 5,000), before later steps gradually turn. Light influences the network’s output; it does not directly assign the fly’s heading.

The 3D view & state synchronization

Position, heading, neural activity, issuance and reward accounting come from the chain. The 3D model interpolates confirmed position changes for a smoother display. Continuous wing motion is a local visual animation, not additional onchain computation.

The page checks shared state about every 5 seconds through a cached server endpoint. Recent history updates less frequently, and background polling pauses while the page is hidden. Pre-transaction checks use fresh reads. A displayed reward can change before a transaction is included.

Camera rotation, zoom and BNB Chain floor opacity are local display controls. They do not submit transactions or change the shared fly. Reading these docs also requires no wallet or blockchain request.

Frequently asked questions

Frequently asked questions
Question	Answer
Can many people mint in one block?	Yes. Successful mints run sequentially, subject to block capacity and the remaining mint allocation.
Can I change the light without advancing?	You can prepare a setting on the page. Applying it onchain also executes the complete fly step.
Why does the fly flap but not move?	Wings animate locally. Coordinates change only when a successful interaction advances the contract.
Why is there no BNB reward?	The fly may still be juvenile, the reward pool may be empty, or another caller may have already collected in that block. Tax tokens may also be awaiting conversion.
Do I get a fly for every mint?	No. Minting gives fungible FLY tokens. Everyone shares the same simulated fly.
Can the old contract still be used?	The previous contract remains onchain. This website’s standard entry uses the current deployment listed below; old issuance and balances are not automatically migrated.

Current contract & permissions

This is the mainnet contract covered by this guide. Dev can activate adulthood and claim dev tax credits. The mint price, tax rate and this deployment’s reward cap are fixed; there is no dev setter for those parameters.

FLY / 0x850c37a1e87194ce12148d2c74fb1cd7d704f0ef

The complete Solidity sources, fly engine and dependencies for both deployments are public. BscScan shows verified source code, and Sourcify verified an exact match for both creation and runtime bytecode.

Current · Verified source Previous · Verified source

Contract events record interactions, liquidity additions, trading activation and completed tax conversions. The website is an interface for reading and calling the contract; onchain state and transaction receipts determine the result.

Enter the experiment