ABCx3 is a game lets players have a say in the board itself. What makes that interesting is that this was never part of Fredrik Borgström’s original plan.
Borgström is the founder and solo developer behind ABCx3, a multiplayer word game built around player-created boards, multi-tile movement and support for a large number of languages. The game has also become a useful example of how a project can change considerably once people other than its creator start using it.
We spoke with Borgström about where the board editor came from, why a seemingly simple two-finger gesture turned out to be difficult to teach, the problems involved in making a word game work across different languages, and how player feedback has changed ABCx3 over time.
It started as a tool for the developer
The most interesting features in ABCx3 weren’t necessarily born from some grand design document. The board editor, which eventually became one of the game’s defining features, started life as something Borgström was building for himself.
It actually happened by accident. My original plan was to make a handful of boards that players could choose from. I was building an editor for myself, not a feature for players.
While working on it, I realized I could use symmetry to make the process much simpler. For a square board with full horizontal, vertical and diagonal symmetry, you can work in one triangular eighth and reflect the pattern across the rest. That also makes the layout compact to store: you keep the representative bonus-square positions and their types, together with the starting square and the information needed to reconstruct the board.
The editor was working so well that I thought, “Why not let other people use it?” The small amount of layout data made that feel practical, too.
I’ve always liked games where you can create something yourself, and I like giving people choices. What began as a tool to help me make content became a way for players to bring their own creativity into the game.
That accidental beginning says quite a lot about the way ABCx3 has developed. The editor solved a problem Borgström had while making the game, but once it existed, there was no reason to keep it locked away.
Of course, giving players a board editor is one thing. Giving them a better way to handle their letters is another.
Getting rid of the tedious part
Anyone who has played a traditional word game knows the routine. You see the word in your head, then start moving the letters into place. Depending on the game and the device, that can mean a series of individual taps and movements before you even get to the interesting part.
Borgström had grown tired of that process himself, which led to ABCx3’s two-finger interaction.
The problem was that the solution wasn’t immediately obvious to everyone else.
I don’t remember who first tried it, but I do remember that getting people to understand how it worked was difficult. That is why I created several videos demonstrating the feature. Having the interaction available wasn’t enough; I also had to find a way to show people what to do.
What I remember very clearly is the frustration that led to the idea. When I played other word games, moving letters one by one always irritated me. I would already have the word in mind, but still have to perform all those separate movements. I’d wanted to solve that for a long time.
The two-finger interaction lets you select an ordered group of tiles and move them together. The aim is to remove some of the repetitive handling between thinking of a word and putting it on the board.
It’s a small example of a useful design principle: if the player already knows what they want to do, the controls shouldn’t make them work harder than necessary to do it.
But ABCx3’s extra freedom creates another problem. If players can change the board, choose settings and experiment with different layouts, the game can quickly become intimidating for somebody who has just opened it for the first time.
More choice doesn’t have to mean more confusion
Borgström doesn’t see freedom and complexity as the same thing. That’s an important distinction in ABCx3, because the game has plenty of room for experimentation without requiring every player to use it.
I think about freedom and complexity as two different things. I want the freedom to be there, but I don’t want everyone to have to deal with every option before they can play.
Symmetry is useful because it makes a layout easier to design and recognize. It doesn’t automatically make every board equally balanced, though, and I wouldn’t claim that all player-created layouts produce the same kind of game. Changing the positions of the bonus squares is part of the experiment.
The familiar framework remains: you’re forming words and deciding where to place them. A new board changes the opportunities within that framework rather than requiring a completely new set of rules.
The same thinking applies to setup. Players who just want a game have simpler routes, while the detailed choices remain in Advanced Game. You don’t have to become a board designer to enjoy what other people create.
That approach also explains why the advanced options haven’t simply been removed. They’re still there for people who want them. The difference is that players don’t have to understand the entire game before they can start playing it.
That lesson came partly from feedback, and one particular player had a surprisingly large influence on the game’s direction.
One long email changed the setup
Player feedback can be vague. “This feels complicated” doesn’t necessarily tell a developer what needs changing. In this case, Borgström received much more specific feedback from a player in Stockholm who was active in a Scrabble Facebook group.
Her comments didn’t just affect the dictionaries. They changed the way ABCx3 introduces its options to new players, and even led to a change in the scoring system.
On the dictionary side, Hungarian feedback has been a useful reminder that a word’s presence in a source isn’t the end of the discussion. People notice questionable words, missing everyday forms and tile spellings that need a closer look. That has led to detailed reviews and corrections rather than treating the initial word list as finished.
But the biggest influence from a single person went beyond dictionaries. A player from a Scrabble Facebook group in Stockholm sent me a long email about what she liked and disliked. One important point was that starting a game was overwhelming. At the time, I essentially had what is now the advanced setup: choose the number of players, the time limit and all the other settings. I saw those as useful choices. She helped me see how much I was asking a new player to process.
That led to the simpler Standard Game and Quick Match setup screens. I kept the advanced options, but stopped making them the only way in.
Her feedback also led me to reduce the maximum letter value from 25 to 15. I’d wanted scoring to reflect how difficult letters are to use, not just copy familiar values. Since the computer calculates the score, I could experiment with a wider range. But a scoring model also has to feel understandable and enjoyable. I kept the weighted approach while reducing the top value.
The interesting part is that the feedback didn’t force Borgström to throw away the systems he’d built. Instead, it changed how much of that complexity players had to deal with at once.
That distinction comes up again when talking about new players.
The first few minutes matter
For a developer who has spent a long time with a game, its rules and interface eventually become second nature. That can make it surprisingly difficult to see the experience through fresh eyes.
Borgström says that was one of the biggest obstacles facing ABCx3.
I think the biggest obstacle is understanding what to do first and what you’re trying to achieve. I know the game so well that it’s easy to forget how unfamiliar it can feel to someone opening it for the first time.
The most important thing I’ve added to address that is a guide/tutorial. It helps players get started with the first steps in a new game while explaining the game’s objectives. I want them to understand not just which action to take next, but what they’re working towards.
The simpler Standard Game and Quick Match setup screens support that, and I’ve also made several videos demonstrating the multi-tile gesture because people found it difficult to understand. But the guide is the central part of helping a new player get started.
The answer also puts the earlier changes into context. The simpler setup screens weren’t about taking options away. They were about making sure players could get into the game before worrying about everything else.
And then there is the sheer amount of language data behind a word game like this.
Supporting languages is more than translation
A menu can be translated. A word game is harder.
Different languages have different dictionaries, inflections, word lengths and relationships between written characters and physical tiles. Even deciding whether a dictionary is actually good enough can require a level of scrutiny that automated checks can’t provide.
It’s much more than translating the menus. Each language needs appropriate word data and tile settings. Plurals and other inflected forms need to follow the policy and sources for that dictionary; I can’t take an English rule and assume it will work everywhere.
Word length also matters in more than one way. There is the question of which words the dictionary admits, and then there is the question of how useful a letter is in play. My scoring calculation gives more weight to letters appearing in short words, and also takes their occurrence at the beginnings and ends of words into account. A raw frequency count doesn’t tell the whole story.
Hungarian has been a particularly instructive example. A large generated dictionary can contain questionable forms, but replacing it with a much smaller list can also remove perfectly ordinary inflections. That means investigating individual cases, checking the sources and listening to people who know the language, rather than assuming that either a larger or smaller word count means a better dictionary.
Hungarian classic-tile play also challenged the assumption that written characters map neatly to individual tiles. Doubled multi-letter tiles can have shortened written spellings. That needed specific dictionary and tile-sequence handling, not simply the same assumptions used for English.
The broad lesson is that language support is ongoing work. A successful import or a large word list is not the same thing as a dictionary that players trust.
The Hungarian example is particularly revealing because it shows how quickly a seemingly simple localisation problem can become a game-design problem.
A bigger dictionary isn’t automatically better. A smaller one isn’t automatically cleaner. And written characters don’t always correspond neatly to the physical tiles a player sees.
For a word game, those details aren’t cosmetic. They directly affect what players can play and how they understand the rules.
Where AI helps a solo developer
Borgström is also using AI tools during development and localisation. For a solo developer, the appeal is fairly obvious: there are plenty of repetitive jobs and technical problems that can consume time.
But ABCx3 also provides a good example of where automation has limits, particularly when language and player experience are involved.
Artificial intelligence (AI) tools have helped with parts of implementation, repetitive development work and localization. As a solo developer, that assistance makes it easier to explore solutions and work across many parts of the project. They’ve also been used for some promotional images; the gameplay recordings are actual captures of the game.
But generating something is not the same as knowing that it’s right. Code still needs checking and testing. A translation can be grammatically plausible but use the wrong word-game terminology. A dictionary entry can pass automated checks and still be something a native speaker finds inappropriate for play.
The decisions about what the game should be, which feedback to act on and what is ready to release are mine. These tools can help me implement an idea, but they can’t replace the experience of a real player finding a screen overwhelming—or deciding whether a particular change makes the game more enjoyable.
For Borgström, AI is another tool in the development process, not a replacement for testing or judgement.
That matters even more for ABCx3 because so much of the game depends on things that are difficult to judge automatically. A translation can be technically correct and still sound wrong to someone who actually plays word games in that language. A dictionary can pass a check and still contain words players don’t expect to see.
The same applies to design feedback. A tool can help implement a change. It can’t tell the developer whether that change actually made the game better.
When the iPhone Duo was announced last week, I realized my game also has a feature that is quite uncommon today: It has a fully responsive layout, so I made a new video showcasing it
Knowing when to listen—and when to wait
The biggest change to ABCx3 wasn’t a new mechanic or a new language. It was a change in how Borgström thought about the freedom he’d already built.
Looking back, he also recognises another lesson that is particularly relevant to solo development: listening to players doesn’t mean acting on every suggestion immediately.
The biggest change was in how I presented the freedom I’d built. Initially, I thought giving players all the settings up front was a good thing. Feedback showed me that having choices and being confronted with all of them at once are not the same experience.
I didn’t need to abandon the flexibility. I needed a simpler way into it. The scoring change taught me something similar: a model can make sense to me as its designer and still benefit from adjustment when people actually play with it.
I’ve sometimes reacted too quickly to feedback. A friend would suggest something and I’d almost immediately implement it. With so many changes over the course of development, I’ve learned that listening carefully doesn’t have to mean implementing every suggestion immediately.
I’ve recently added polls to the game’s news section, and I’m using them a lot. Players can vote on features they want—or don’t want—and changes they’d like to see. It gives them a direct way to contribute to the game’s direction.
My advice would be to start with something you genuinely want to improve, as I did with moving tiles one by one. Let people try it, listen for the problem behind their suggestion, and be willing to change the route into your game without losing what makes it interesting. And leave room for accidents: my own board editor turned out to be a feature I hadn’t originally planned to give to players.
And that brings us back to the board editor.
It is perhaps the best example of everything Borgström has described throughout the interview. He started with a personal problem, built a solution, realised it could be useful to other people, and then let players help shape what came next.
ABCx3 hasn’t simply grown by adding more features. Its development has been about figuring out which ideas are worth keeping, which need changing, and how to make the game’s deeper systems accessible without taking away the freedom that makes them interesting.
In ABCx3’s case, one of its most distinctive features came from doing exactly that. It wasn’t planned. Borgström simply built something he needed, saw that it worked, and decided to let the players in.
It’s awesome when the unexpected part of development turns out to be the part worth keeping.
ABCx3
Developer: Fredrik Borgström
Role: Founder and solo developer
Game: ABCx3
Focus: Multiplayer word game with player-created boards and multi-tile interaction
Leave a comment