Inspiration
bricolang started from a plain linguistic idea: a word does not carry meaning by itself. Its meaning comes from how it has been used and connected to other words over time. We wanted a game where that was not a metaphor but the literal mechanism, so meaning does not exist on the board until it emerges from your own bonds. A sign holds only a shape; a separate structure, the lexicon, grows the meaning behind it purely from a history of connections, the same way an entry in a real dictionary is really a record of how a word has been used.
How we built it
Every sign carries only a shape and a lineage, nothing else. Meaning lives in a lexicon that keeps a probability distribution for every symbol and every bond, and it is that distribution, not the symbol, that a connector reads when you bond two signs together. Some connectors are deterministic and always answer the same way; others waver, drawing from the distribution and narrowing it with each use, until repetition lets a bond settle into a stable, coined word. Color and sound are both computed from that same distribution, so a meaning always looks and sounds like itself wherever it appears, and a glyph is drawn by recursively composing the two signs its bond came from, so a word's shape keeps its own etymology.
A word's identity had to be a fixed-length value rather than the fully expanded expression that produced it, since expressions nest without limit as players build words out of words. We settled on a 128-bit signature built from a bond's two child signatures (already short) and its connector, so identity size stays flat no matter how deep the language grows. The second, paid world plugs into the same engine through a swappable per-world table for how signs are drawn and how glyphs compose, and its own voice, so a new world is new material - new signs, new sound, its own separate lexicon - without touching the free world. A RevenueCat check gates entry to that world at launch and whenever the world list opens.
Challenges we ran into
The most direct collision with the game's own rules was a feature we had to remove. Early on, the game showed a target sound and asked the player to work toward it. But nothing in the model supports aiming: a deterministic connector answers a pair it has never seen with a neutral result, and a wavering connector draws from a live distribution - neither can be steered toward a chosen outcome. On a real device, a tester's honest reaction was that reaching for the target felt close to impossible, and that progress instead felt like poking around at random and later noticing that something had been achieved. We removed the whole feature rather than fake a solution the model could not actually give, and let unlocking be driven by how deep a player nests bonds instead.
We also hit the same structural bug three separate times: treating a DAG as if it were a tree. A word's identity, a word's saved data, and a glyph's rendering all reference shared sub-parts rather than duplicating them, and naive recursive code that ignores that sharing explodes. The worst case: identities that fully expanded into strings 5,382,195 characters long and a save file of 371MB, large enough that just opening the board got the app killed by the watchdog. Glyph rendering hit the same trap independently: a real board with only 318 distinct glyph nodes turned into 24.6 billion recursive calls before we added memoization. Each time, the fix had the same shape - remember what has already been visited, and walk the shared structure once.
What we learned
The clearest lesson was that a feature can look sound on paper and still be impossible in practice, and the only way we found out was by putting a real board, played by a real person, in front of the design. The target-aiming feature read fine as a design and only failed once someone actually tried to hit the target. We now keep a heavily-played real board as a fixture for exactly this reason: a freshly created board never reproduces the problems that only appear once a language has grown deep. We also learned to be suspicious of our own recursive code whenever a structure can share parts. It is easy to write something that is correct on a small example and exponential on a real one, and we now assume any newly composed recursive structure is a DAG until proven otherwise.
bricolang is a game about a language that does not exist yet, until you make it.
There is shape, color and sound. Touch a sign and it sounds; bond two of them and the sounding changes. Keep going, and there comes a moment when the sounding settles, and something comes into being and joins your hand. That new word is a sign too: you can bond it again, and build words out of words.
WHAT YOUR HANDS DO
- Tap a sign in the palette at the bottom to place it on the board.
- Drag from one sign to another to bond them, with the connector selected in the palette.
- Tap a bond again and again. It speaks each time, and the ring around it fills.
- When the ring is full, a word is coined. Its mark appears under the ring at the top right, then flies down into your palette.
- Press and hold a sign, then drag, to carry it. Press and hold empty space, then drag, to enclose a region.
- A button appears under the ring. Tap it once and the enclosed signs speak; tap it again and they fold into a single bond.
- Tap the ring at the top right and the whole board speaks in turn.
- Tap a new word's mark to save it to Photos as a card; press and hold it to share.
HOW IT BEHAVES
- Meaning lives in the bonds, not in the signs. Every sign begins with the same potential and is told apart only by its shape; what a bond means grows out of how you use it.
- Nine connectors. Some are fixed and answer like a rule, so they never add a word. Others waver: every sounding is drawn from what the bond could still become, and each one narrows it, until it settles into a word.
- Each connector also takes on your own leaning as you use it, and that leaning reaches pairs you have never bonded. The connector lines in the palette drift apart in color as it happens.
- Color and sound come from the same values, so the same meaning always looks and sounds the same. Every sound is synthesized at the moment you hear it, and the more a bond has settled, the closer its pitch snaps to a scale.
- Underneath everything, the whole board sounds as one: a looping eight-beat bar whose downbeats never move, and which fills in as the board grows. It plays alongside music from other apps.
- Going deeper opens more. Nesting bonds inside bonds unlocks new signs and new connectors.
- The world has no edge. Signs that drift off-screen gather into markers along the border, by direction; tap one to bring the nearest sign back.
- Your language is saved on your device.
WORLDS (IN-APP PURCHASE WITH REVENUECAT)
bricolang can be played in more than one world. Each has its own signs, its own voice and its own lexicon.
- ogn, the world you start in, is free in full.
- mss is an additional world, sold as a one-time purchase. Its signs are filled surfaces instead of lines, and when one filled glyph directly encloses another, the inner one is cut out as a hole. Its voice sits half an octave lower, and its sounds rise in more slowly.
- The lexicons are separate, so a world is not a level you advance to. It is another place to start.
- The list of worlds opens from the small square mark at the top left. An unowned world shows its price, as the App Store formats it, inside a slowly pulsing outline. Tap the outline to buy. At the bottom right of that screen, a small underlined "Restore Purchases" brings back past purchases; it is shown only while a purchasable world is still unowned.
On screen, the only letters are in that list: each world's name, its price, and that restore link. A saved card carries the app's name, small, in one corner.
Log in or sign up for Devpost to join the conversation.