Wayword

Wayword is a consequence-driven language app for Japanese and Mandarin. Explore an inhabited tiny planet, read your surroundings, talk to locals, and watch your words shape what happens.

Comment

About Wayword

Speak, and the little world answers.

Wayword is a consequence-driven language-learning game for Japanese and Mandarin Chinese (for now). It turns language practice into a place: an inhabited tiny planet where learners notice clues, speak to characters in their own words, and see the world change according to what those characters understood.

Inspiration

Language learners can know a long list of words and still freeze when a real conversation becomes incomplete, social, and unpredictable. Flashcards are good at recognition, but they rarely teach the feeling of asking a follow-up question, repairing a misunderstanding, choosing the right level of formality, or living with the consequence of an ambiguous request.

Wayword began with a simple question: what if speaking a language felt less like filling in a worksheet and more like belonging to a small place? We wanted every phrase to have context. A shop should have signs to read, a friend should remember what was said before, and a restaurant order should become a visible dish rather than a green check mark.

The project's visual direction was also informed by the density, readable silhouettes, illustrated atmosphere, and embodied traversal of the Messenger Awwwards experience. We treated that work as interaction and art-direction research only. Wayword's planet, regions, characters, missions, dialogue, models, textures, and identity are original.

What it does

Wayword places the learner on a connected spherical world spanning seven regions, four enterable interiors, and ten authored missions. Players can walk or click to travel, explore Japanese and Mandarin districts, read physical signs and menus, and approach characters naturally rather than choosing a lesson from a dashboard.

During a mission, the learner responds freely. An NPC may understand the request, ask for clarification, react to an inappropriate register, or reveal that an important detail was missed. Those interpretations produce visible consequences: ingredients appear on a counter, a ticket purchase advances, a friend's posture changes, or a repair stage opens. Afterward, private field notes separate communicative success, comprehension, grammar, naturalness, social appropriateness, and independence instead of reducing the exchange to a single right-or-wrong score.

Optional English translations, furigana, romaji, pinyin, response starters, and replay controls make the same world approachable at different levels. Progress, collected phrases, mission reports, and allowlisted NPC memories are stored locally so returning characters can recognize meaningful details from earlier encounters.

How we built it

Wayword is built with React, TypeScript, Next.js through vinext, Vite, Three.js, React Three Fiber, Drei, Zod, and the official OpenAI JavaScript SDK. Its Cloudflare Workers-compatible build is hosted privately with OpenAI Sites.

The world is data-driven rather than arranged as one large scene file. Regions, routes, terrain, buildings, props, interiors, NPC routines, contextual interactions, and mission anchors are authored as structured data and checked by a world validator. Original asset-generation and packing tools produced a cohesive release of 92 environment models and eight rigged character models, while demand loading and quality profiles keep the illustrated planet responsive.

Movement on a tiny planet requires spherical rather than flat-world geometry. For two unit vectors $\mathbf{u}$ and $\mathbf{v}$ on a planet of radius $R$, the surface distance is

$$ d = R\arccos\left(\operatorname{clamp}(\mathbf{u}\cdot\mathbf{v}, -1, 1)\right). $$

That same local tangent frame informs movement, character heading, collision, pathfinding, camera orientation, NPC routes, audio surfaces, and map previews. A shared planner chooses a safe direct path when possible and otherwise uses weighted A* over the authored route graph before smoothing valid shortcuts.

The AI layer has a deliberately narrow job. In live mode, GPT-5.6 interprets the learner's meaning and performs the NPC through structured Responses API output. It does not control mission truth. Strict Zod schemas validate the result, and a deterministic mission engine recomputes requirements, selects the permitted consequence, and allowlists relationship and memory changes. Mock mode and labelled deterministic fallbacks keep every mission playable without a successful model call.

We built the project with verification as part of the architecture. Formatting, linting, type checks, hundreds of focused unit tests, production builds, rendered-HTML smoke tests, world-density validation, fixed-view captures, mission replays, journal viewport checks, motion telemetry, and performance profiles all guard the same systems that run in the game.

Challenges we ran into

The hardest challenge was making a spherical world feel ordinary to control. Every familiar assumption about “up,” forward motion, camera yaw, collision, and route direction changes as the player moves around a globe. Early versions could steer inconsistently, walk in place against obstacles, accumulate a broken run pose, or let the camera influence movement in the wrong frame. We solved these problems by sharing one transported local frame, advancing motion in bounded substeps, driving animation from measured post-collision travel, and testing outdoor and interior controls together.

Visual density created the opposite problem: a world can contain many objects and still feel empty. The first spherical composition spread its buildings and routes too far apart, producing wide bare foregrounds. We reduced the world's scale, narrowed streets, moved authored structures closer to the paths, added semantic scenic kits, and made density measurable through validators instead of relying on object count alone. We then had to balance that richness against draw calls, asset streaming, shadows, collision cost, and mobile performance.

Free-form AI dialogue also needed a clear trust boundary. Model output can be creative, delayed, unavailable, or structurally invalid; none of those states should corrupt progress or spend quota needlessly. The solution was to keep mission authority in deterministic application code, treat learner and memory text as untrusted data, validate every boundary, reject stale responses, and fall back safely when the provider is unavailable.

Finally, a multilingual game puts unusual pressure on interface layout. English, kanji, kana, furigana, romaji, hanzi, and tone-marked pinyin all have different line-height and wrapping behavior. Keeping the planet visible while making journals, dialogue, and learning reports readable across short, portrait, mobile, keyboard, and zoom-equivalent viewports required dedicated containment and accessibility tests.

Accomplishments that we're proud of

  • We built one physically connected tiny planet instead of disguising a lesson picker as a world. Its regions, interiors, loops, hidden route, characters, contextual interactions, and mission locations can all be reached through embodied travel.
  • We made language create visible and social consequences. A learner can repair an order, clarify a travel request, support a friend, and return to an NPC who remembers a meaningful detail.
  • We separated expressive AI performance from deterministic game authority, so open-ended conversation can coexist with reliable progression, safe memory, and reproducible testing.
  • We replaced placeholder-looking scenery with a cohesive authored world: 92 environment GLBs, eight rigged characters, illustrated materials, physical target-language signs, region-specific ambience, and layered environmental motion.
  • We made assistance supportive rather than punitive. Learners can choose the amount of scaffolding they need, while feedback reports independence honestly without treating help as failure.
  • We turned quality goals into repeatable evidence. Movement, pathfinding, camera behavior, mission flows, world structure, responsive layouts, and performance are backed by focused validators and acceptance harnesses.

What we learned

We learned that AI is most useful in a game when it expands expression without owning the rules. Letting a model interpret meaning and embody a character creates flexibility; letting deterministic code authorize progress and memory creates trust.

We also learned that world quality is relational. Better models alone do not make a place feel alive. Scale, route width, camera distance, silhouettes, lighting, NPC routines, signs, sound, collision, and the spacing between points of interest must reinforce one another. On a small planet, a single change to movement or scenic massing can affect navigation, animation, performance, and composition at once.

Most importantly, we learned to design language practice around meaning rather than perfect strings. A useful learning system must recognize partial success, make misunderstanding recoverable, respect cultural context, and show the learner what happened before explaining it.

What's next for Wayword

The next step is to grow Wayword from a polished compact world into a longer learning journey. That means additional regions and follow-up missions, Traditional Chinese and future language packs, richer listening material, and more long-term NPC callbacks that make relationships feel cumulative.

We also want optional consent-based speech input and pronunciation support, cloud progression with a versioned local-to-account migration path, and broader human testing across routes, browsers, mobile devices, GPUs, and accessibility tools. Before any high-traffic release, the live AI path also needs a shared edge rate limiter and production quota monitoring.

The long-term goal remains the same: build a world where language is not a quiz you leave behind, but a way to notice, act, repair, remember, and belong.

Built With

Share this project:

Updates