What If Intelligence Didn’t Need Floating Point?
Modern AI runs on floating-point arithmetic. Billions of float32 parameters, massive matrix multiplications on GPU tensor cores, gradient descent through computational graphs so deep they need mixed-precision training just to fit in memory. It works — spectacularly — but it comes with an implicit assumption: intelligence requires precision. That the difference between 0.7823451 and 0.7823452 matters.
Bytefield asks a different question. What if intelligence could emerge from nothing but a flat array of bytes and integer operations? No floats. No matrices. No gradients. Just bytes — values from 0 to 255 — connected by simple integer arithmetic, ticking forward at 60 cycles per second.
This isn’t a replacement for FENA or transformer architectures. It’s an experiment in minimalism: how little computational machinery do you actually need for adaptive behavior to emerge? The answer, it turns out, is surprisingly little. This post covers the Bytefield architecture in depth — from its core data structure to the proof-of-concept that demonstrates emergent intelligence from nothing but integers.
The Byte Array — One Flat Structure, Three Zones
At the heart of Bytefield is a single flat array of bytes. That’s the entire state of the system. No tensors, no parameter matrices, no embedding tables. Just a contiguous block of uint8 values, each ranging from 0 to 255.
This array is divided into three functional zones:
┌──────────────────────────────────────────────────────────────────────┐
│ INPUT ZONE │ INTERNAL ZONE │ OUTPUT ZONE │
│ bytes 0-127 │ bytes 128-895 │ bytes 896-1023 │
│ │ │ │
│ sensory │ connections form here │ actions / │
│ data in │ learning happens here │ responses │
└──────────────────────────────────────────────────────────────────────┘The Input Zone is where the outside world writes data into the system. Sensory observations, environmental signals, incoming messages — whatever the system needs to perceive gets encoded as byte values and placed here.
The Internal Zone is the brain. This is where connections form between bytes, where patterns emerge, where computation happens. It’s the largest zone by far, because this is where all the interesting work takes place.
The Output Zone is where the system’s decisions are read from. Movement commands, action selections, signal outputs — whatever the system does in the world gets read from these bytes.
The beauty of this design is its flatness. There are no layers, no hierarchy imposed by architecture. Any byte in the internal zone can connect to any other byte. Structure emerges from learning, not from engineering.
Connections — The Wiring
A byte array by itself is just data. What makes Bytefield a computational system is its connections — dynamic links between bytes that propagate signals and transform values.
Each connection is defined by four properties: a source byte index (where the signal comes from), a destination byte index (where the signal goes), an operation type (how the signal is transformed), and a weight (an integer value from 0 to 255 that modulates the connection’s strength).
Connections obey one critical constraint: directionality. Signals flow from input toward output. A connection can link an input byte to an internal byte, an internal byte to another internal byte, or an internal byte to an output byte. But a connection can never route signals backward from output to input. This prevents degenerate feedback loops and ensures that information flows through the system in a coherent direction.
There’s also a MAX_SIGNAL cap on every connection. No matter what operation is applied, the resulting signal is clamped to this maximum value. This prevents runaway amplification — a single strong connection can’t flood the entire array with maximum values and drown out everything else.
Signal propagation is straightforward. On each tick, every active connection reads its source byte, applies its operation using its weight, and writes the result to its destination byte. Thousands of connections firing in parallel, every tick, 60 times per second.
byte[24] ──── AND ────► byte[340] ──── SUM ────► byte[912]
(input) (internal) (output)
val: 42 val: ? val: ?The result is a massively parallel signal-processing network built from nothing but byte reads, integer operations, and byte writes.
Connection Operations — Integer Arithmetic as Computation
The operations available to connections are deliberately simple. Every one of them takes two integer inputs — the source byte value and the connection weight — and produces an integer output clamped to 0-255.
AND performs a bitwise AND between the source value and the weight. This acts as a mask or filter: only the bits that are set in both the source and the weight pass through. A weight of 0b11110000 masks off the lower four bits, letting only the high-order bits propagate. This is useful for feature extraction — connections can learn to attend to specific bit patterns in their input.
SUM adds the source value, scaled by the weight, to the destination byte’s current value, clamped to the 0-255 range. This is accumulation — multiple connections can feed into the same destination byte, building up an aggregate signal. The weight controls how much each connection contributes.
OR performs a bitwise OR, combining signals additively at the bit level. XOR performs exclusive-or, which is useful for detecting differences between signals — it outputs high values when the source and weight disagree and low values when they match.
Why integer-only? Three reasons. First, determinism: the same input produces the exact same output every time, on every platform. No floating-point rounding differences between x86 and ARM, no subtle nondeterminism from fused multiply-adds. Second, portability: integer arithmetic runs on anything with a CPU — microcontrollers, FPGAs, embedded systems, bare metal. No GPU required. Third, simplicity: the entire runtime can be implemented in a few hundred lines of C. If you can’t do it with integers, you shouldn’t do it. That’s the Bytefield philosophy.
Always-On Self-Supervised Learning
There is no training phase in Bytefield. There is no inference phase. There is only running.
Learning happens continuously, on every tick, as an intrinsic part of the system’s operation. Connections are created, strengthened, weakened, and pruned based entirely on local activity — no external supervisor, no loss function, no optimizer.
The rules are simple. When a connection propagates a signal that contributes to meaningful output — when the destination byte changes in a way that correlates with useful behavior — the connection’s weight is incremented. It gets stronger. It’s more likely to propagate a similar signal next time.
When a connection consistently fails to contribute — when its destination byte doesn’t change, or when the output zone shows no meaningful activity correlated with this connection’s firing — the weight decrements. The connection weakens. If it drops to zero, the connection is pruned entirely, freeing up capacity for new connections to form.
New connections spawn spontaneously. When a byte in the internal zone is active but has few incoming connections, there’s a probability of a new connection forming from a random active source byte. This exploration mechanism ensures the system keeps discovering new signal pathways, not just reinforcing existing ones.
This is Hebbian learning in integer clothing. “Bytes that fire together wire together.” But unlike classical Hebbian learning, which can suffer from unbounded weight growth, Bytefield’s integer constraints provide natural regularization. Weights are clamped to 0-255. Signals are clamped by MAX_SIGNAL. The system can’t explode — it’s bounded by the byte range itself.
The contrast with traditional machine learning is stark. There’s no loss function defining what “correct” means. No optimizer computing gradients. No backward pass. Just local reinforcement: connections that work get stronger, connections that don’t get weaker. Intelligence isn’t trained into the system. It grows.
No Floats — A Design Philosophy
The integer-only constraint isn’t a limitation to be worked around. It’s the core design principle. Every architectural decision in Bytefield flows from the commitment to integer arithmetic.
This means perfect determinism. Run the same Bytefield system with the same initial state and the same input sequence, and you get the exact same output, bit-for-bit, every single time. On any platform. On any CPU. This is impossible with floating-point arithmetic, where operation ordering, fused multiply-adds, and platform-specific rounding modes can all introduce subtle variations.
It means radical portability. A Bytefield brain runs on a Raspberry Pi. It runs on an Arduino. It could run on an FPGA with a few days of work. No CUDA, no cuDNN, no tensor libraries. Just integer math and array indexing.
It means accepting constraints. You can’t represent 0.7823451 as a byte. Weighted averaging requires creative rounding strategies. Precision is coarse — 256 possible values per byte, compared to the billions of distinct values in a float32. But consider this: biological neurons don’t use floating point either. They fire or they don’t, with varying frequencies and timings. Action potentials are all-or-nothing events. Synaptic strengths are modulated by discrete molecular processes. If biology can produce intelligence without IEEE 754, maybe integers are closer to the right abstraction than floats ever were.
System Input Zone — Always-On Sources
The input zone doesn’t just sit empty waiting for external data. It includes always-on internal sources that provide continuous background signal, ensuring the system is never truly idle.
Oscillating bytes cycle through values in repeating patterns. They follow integer approximations of sine waves — ramping up from 0 to 255, back down to 0, and up again — at various frequencies. Some oscillate quickly (every few ticks), some slowly (over hundreds of ticks). These provide rhythmic timing signals that connections can learn to synchronize with. A connection that fires in phase with a particular oscillator effectively has a clock — it can learn to do things periodically.
Incrementing bytes steadily increase by 1 each tick, wrapping around from 255 back to 0. These provide a raw sense of time passing. A connection that reads an incrementing byte knows “how long” it’s been since the byte last wrapped — a primitive temporal signal that enables sequence-dependent behavior.
These always-on sources ensure there’s always signal flowing through the system, always activity for the learning rules to act on. Even with no external input, the system is alive — connections are forming, strengthening, and pruning in response to the internal rhythms.
The biological parallel is striking. The brain is never silent. Theta rhythms, alpha oscillations, circadian signals — there’s always background neural activity providing timing and context. Bytefield’s oscillating and incrementing bytes serve the same function: a substrate of rhythmic activity on which learned behavior is overlaid.
Meta Output Zone — The Commit Mechanism
Writing to the output zone isn’t enough. Bytefield includes a commit mechanism that prevents half-formed outputs from being read by the external system.
A subset of the output zone bytes are designated as meta-output bytes. These don’t encode actions directly — they encode readiness. The system must write specific values to these meta-output bytes to signal that its output is complete and should be read. Until the commit signal is present, the output zone is treated as in-progress and ignored by whatever external system is consuming it.
This is analogous to a transaction commit in a database. You don’t want to read a row that’s halfway through being updated. Similarly, you don’t want to read a Bytefield creature’s movement command when the system has only computed half of it. The commit mechanism ensures atomicity: outputs are either fully formed or not visible at all.
The commit mechanism itself is learned, not hardwired. The system must develop connections that write to the meta-output bytes at the right time — after the output bytes contain a coherent action. This is itself an emergent behavior: the system learns not just what to output, but when to output it.
Connection Delays — Thinking Across Time
Not all connections propagate instantly. Each connection can carry an integer delay value, specifying how many ticks should elapse between reading the source byte and writing to the destination byte.
A connection with a delay of 0 propagates immediately — same tick. A connection with a delay of 10 holds its signal for 10 ticks before delivering it. The source byte’s value at tick N arrives at the destination byte at tick N+10.
This simple mechanism creates temporal dynamics. A destination byte can receive signals from the same source at multiple delays — seeing not just the current value, but values from 5, 10, and 20 ticks ago simultaneously. This allows the system to learn temporal patterns: sequences, rhythms, cause-and-effect relationships that play out over time.
Without delays, Bytefield would be a purely reactive system — responding only to the current snapshot of input. With delays, it becomes a temporal processor, capable of recognizing that “A followed by B followed by C” is different from “C followed by B followed by A.” This is essential for any behavior more complex than stimulus-response.
The implementation is simple: each delayed connection maintains a small circular buffer of past source values, indexed by tick count. Integer arithmetic, array indexing, no floating point. Temporal computation from nothing but bytes and patience.
60hz Continuous Ticking
Bytefield runs at 60 ticks per second. Continuously. Without stopping.
Every tick, the same sequence executes: all input bytes are updated (external data written, oscillators advanced, incrementors incremented). All connections propagate (source bytes read, operations applied, destination bytes written, delays advanced). All learning rules fire (weights adjusted based on activity). All output bytes are available for reading (if the commit signal is present).
There is no “training mode” versus “inference mode.” There is no distinction between learning and acting. The system is always doing both, simultaneously, on every tick. This is fundamentally different from the train-then-deploy paradigm of conventional AI. A Bytefield system that’s been running for a million ticks is still learning on tick 1,000,001. It never stops adapting.
The 60hz rate is a deliberate choice. It’s fast enough for real-time interaction — responsive enough for a game-like simulation or a robotic controller. It’s slow enough that the computational overhead is modest — even a low-end CPU can run thousands of connections at 60hz without breaking a sweat. And it’s a nod to biological neural oscillation frequencies: 60hz sits squarely in the gamma band, the frequency range associated with conscious processing and information binding in the brain.
The Proof of Concept — A 2D Grid World
Theory is nice. Demonstration is better. Bytefield’s proof-of-concept is a 2D grid world populated with creatures, each one running its own Bytefield brain.
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ │ │ ◆ │ │ │ ● │ │ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ ● │ │ │ │ ◆ │ │ │ ◆ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ │ │ │ ▲ │ │ │ ● │ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ │ ◆ │ │ │ │ │ │ │
└───┴───┴───┴───┴───┴───┴───┴───┘
◆ = food ● = creature ▲ = player creatureEach creature’s input zone receives sensory data about the cells surrounding it — what’s nearby, whether there’s food, whether there are obstacles or other creatures. This data is encoded as byte values and written into the creature’s byte array every tick.
Each creature’s output zone is read for movement commands — up, down, left, right, or stay. The bytes in the output zone are interpreted as directional signals, and the highest-valued direction wins.
Between input and output, the creature’s internal zone does its work. Connections form. Signals propagate. Learning rules fire. Some connections learn to route food-detection signals toward the “move toward food” output bytes. Others learn to route obstacle-detection signals toward avoidance outputs. The creature develops behavior — not because we programmed it, but because the connections that lead to food-finding get reinforced, and the connections that don’t get pruned.
The evolutionary pressure is straightforward: creatures have energy. Moving costs energy. Eating food restores energy. When a creature’s energy hits zero, it dies and is removed from the grid. Creatures that eat enough food survive and reproduce, passing their connection patterns (with small mutations) to offspring.
Over generations, the grid world comes alive. Early generations stumble around randomly — their connections are noise, their behavior is chaos. But natural selection is relentless. Creatures that happen to develop connections routing food signals to approach outputs survive longer and reproduce more. Within a few hundred generations, most creatures exhibit clear food-seeking behavior. Within a few thousand, you see obstacle avoidance, energy conservation (not moving when there’s no food nearby), and even rudimentary competition strategies.
All from nothing but bytes, integer operations, and selection pressure. No neural network architecture. No training pipeline. No loss function. Just a flat array of bytes, learning by doing, 60 times per second.
Where Bytefield Goes Next
Bytefield is not a competitor to FENA, or to transformers, or to any production AI architecture. It’s a philosophical experiment made concrete — a proof that adaptive behavior can emerge from radically minimal computational machinery.
What it shares with FENA is a set of deep convictions: that learning should be continuous, not separated into training and inference phases. That local learning rules can accomplish what global optimization claims to require. That biological inspiration means taking biology’s constraints seriously, not just borrowing its vocabulary. These shared principles are explored in depth in our post on design principles for brain-inspired AI.
Bytefield is early-stage, experimental, and intentionally constrained. The grid world proof-of-concept demonstrates emergence, not capability. But it demonstrates something important: the floor for emergent intelligence is lower than most people assume. You don’t need billions of parameters. You don’t need floating-point precision. You don’t need GPUs. You need a substrate that can form connections, a mechanism for reinforcing useful ones, and time.
Where does Bytefield research go from here? Scaling the byte array to larger sizes. Exploring richer connection operations. Testing whether Bytefield brains can learn tasks beyond grid-world navigation — pattern recognition, sequence prediction, simple communication. And asking the question that drives all of this work: just how far can integers take us?