Wait, Are We Co-Developers Now? How We Generated Content for a VR Word Game

At our core, we are a versatile team. If you look at our service portfolio, you’ll see the classics: localization, editing, narrative design, voice-overs, LQA, 2D/3D art, and animation. It’s a big list. But even with all those boxes checked, clients occasionally come to us with tasks that don’t quite fit into a standard category. And we love those tasks. We want to share a story about one of these non-standard cases—a project where we stepped out of our usual role and helped a client build the very foundation of their game.

Content:

• Building a Dictionary from Scratch
• Setting the Rules of the Game
• Phase 1: The AI Pipeline
• Phase 2: The “Subgram” Challenge
• The Result: Plug-and-Play Content
• Why We Do It?

Building a Dictionary from Scratch

We were approached by Field of Vision, which is currently developing an immersive VR game: Wordomi. The core mechanic involves the player using cubes to assemble words. But to make the game truly engaging, the client needed more than just a word list. They needed a way to guide the player and provide context. This meant every single word required a hint (for the puzzle aspect) and a dictionary definition (so players could learn the meanings of new words).
The mechanics were fun, but populating the game wasn’t an easy task. Picking thousands of words, ensuring they fit specific lengths, writing unique definitions, and crafting helpful hints for every single one was taking up valuable development time. It was tedious and complex and distracted them from polishing the VR experience.

Breakdown of the number of sets (word, hint, definition) for each word length in characters.

We saw an opportunity to help. We thought,

“We work with words every day. Why don’t we handle the content generation?”

Setting the Rules of the Game

Before writing a single line of code or text, we sat down to define the architecture. This wasn’t just a list of words; it was game design. We had to consider the technical constraints and the player experience.

We established the key requirements:

• Game Modes & Mechanics: How do words overlap across different topics? What are the minimum and maximum letter counts?
• Context is King: A word like “bank” can mean a financial institution or the side of a river. We agreed that every definition and hint must be strictly tied to the specific theme. This ensures the player can logically connect the hint to the target word.
• VR Readability: VR isn’t the medium for reading essays. We agreed that definitions had to be concise. No “walls of text”—just brief, digestible explanations that don’t overwhelm the player or break immersion.
• The “Soul” Factor: The client didn’t want dry, robotic instructions. They needed to be lively—not “stuffy”—to keep the gameplay feeling fresh and fun.
• Safety & Rating: We set strict content filters. No vulgarity, no slurs, and no sensitive content that would violate the game’s age rating.

Phase 1: The AI Pipeline

Once the rules were set, the work began. We didn’t just want a list; we wanted a high-quality database.

1. Generation: We created and trained a model specifically to generate words of a certain length within specific themes.
2. Validation: Relying solely on generation is risky. We used a secondary tool—drawing on our localization QA experience—to filter the results. This tool checked for errors, ensured strict adherence to the technical brief, and, most importantly, checked for AI hallucinations. We had to ensure every word actually existed.
3. Creative Content: Once we had the approved words, we moved to the next stage: generating the definitions and hints. This is where we tuned the model to follow our stylistic requirements—keeping definitions short for VR and ensuring hints were witty and engaging.
4. Final QC: A final tool verified the output. If a word or definition didn’t meet our quality standards or length constraints, it was rejected, and the system would automatically re-run the process to top up the volume until we hit the target.

Phase 2: The “Subgram” Challenge

Just when we thought we had a rhythm, we tackled the “Subgram” mode. The game design here was significantly different. In this timed mode, the player is given a set of random letters and has to assemble as many words as possible from them.

This presented two specific headaches:

1. The Source Set: We needed to generate “starting hands” of letters. If a set has too many repeated letters (e.g., “GIINNNSS”), the number of possible words drops drastically, ruining the player’s experience.
2. The Combinations: We needed to provide the game engine with every possible valid combination of words for those letters so the game could validate the player’s answers.

For the first point, we built a dedicated generator with strict “balance rules.” It limits the repetition of specific characters and ensures a healthy mix of vowels and consonants. We also added a validation step to the pipeline: if a generated hand didn’t offer enough potential word variations, it was automatically discarded and regenerated.

Ratio of the number of word sets (word, hint, definition) between subgrams and other modes.

The second point required a pivot in strategy. We couldn’t use generative AI here. Why? Because generative models are creative, not exhaustive. If we asked an AI to “list all the words you can make from these letters,” it might miss a few or invent one that doesn’t exist. In a puzzle game, that’s a game-breaking bug.

The Solution: Instead of generating, we went to the source. We parsed reliable dictionaries to extract every mathematically possible word for each letter set.

But dictionaries are messy. They contain morphemes (prefixes, suffixes), archaic entries, and sensitive vocabulary that we didn’t want in the game. To fix this, we re-tuned our verification model to act as a rigorous filter. It cleaned the results, leaving us with a pristine list of playable words. This approach ensured maximum variation for the player while completely eliminating the risk of hallucinations.

The Result: Plug-and-Play Content

Because we worked so closely with the client, we didn’t just send them a text file. We delivered the data in a specific structure that allowed them to implement it directly into the game engine without any additional processing or manual copy-pasting.

Screenshot from the game Wordomi

But the value didn’t stop at the initial delivery. We now have a fully established technical pipeline that makes generating future content incredibly simple. If the client decides they need a specific “Halloween” pack or a “Christmas” event, they literally just have to ask for the theme. We run our process and hand over a file that is ready to upload.

This capability makes it effortless for the client to release seasonal updates or new level packs. It keeps the game fresh and encourages players to keep coming back—all with absolute minimum effort from the developer’s side.

Why We Do It?

We are incredibly grateful for this experience. It allowed us to dive deep into the mechanics of game development, which is perfect because video games are our main passion.

This case proves that we aren’t just a service provider; we are a partner. We are always ready to help our clients realize their ideas, no matter how unconventional the task. Our goal is simple: We take on the heavy lifting so you can focus on your priorities.

Need help with a “non-standard” task for your game? Let’s talk.