Project note ยท 2014
Stars
Stars was a small cross-platform action game about guiding a fallen star home. Looking back, the interesting part is less the size of its audience than how much engineering had to disappear before the game could feel simple.
A simple gesture, rebuilt seven times
The premise was straightforward. A little star had fallen from the sky and needed to find its way home. Players drew a path directly on the screen, collecting star dust, avoiding or eliminating enemies and picking up power-ups along the way. The original launch material described an initial 18 levels built around that simple interaction.
Making the gesture feel natural was anything but straightforward. The input system was rewritten seven times. Each pass added more engineering underneath, while the goal above the surface stayed the same: the player should think about where the star should go, not about how the control system worked.
The paradox was that a more natural feel required more technology. The more technology we added underneath, the better we became at hiding it.
One game, many platforms
Stars was built in C++ on the Marmalade SDK. By 2016 the project had travelled across Apple iOS, Google Android, Amazon’s Kindle Fire ecosystem, Windows Store and Samsung bada. The first release material documents availability through Apple’s App Store, Google Play and Amazon for Kindle; later porting work took the same game into additional stores and devices.
That portability was not an abstract feature. It meant cross-compiling, handling platform differences and testing on the actual devices. Mobile hardware was still constrained enough that on-device testing was a requirement rather than a final check.
The relationship with Marmalade also became part of the story. Porting the game led to contracted work around bringing it to other stores. Samsung provided prototype phones for its then-new bada platform so the game could be tested before the devices and operating system were broadly available.
Stars never developed a large install base, but it attracted an unexpected kind of attention. App-store operators were proliferating at the time, and several of them wanted recognisable games in their catalogues. For a small project, that created partnerships and technical opportunities that mattered more than the download count itself.
Graphics, animation and tools
The project became a practical education in graphics programming. Working close to OpenGL meant learning to treat texture memory, UV mapping and draw-time efficiency as real design constraints rather than implementation details.
Collision detection used Box2D, and the work around Stars also led to contributions in that area. For character animation we built a dedicated client around Esoteric Software’s Spine animation suite. The levels themselves were driven by a small domain-specific language, so new levels could be added largely as content instead of requiring changes to the game code.
This was before today’s default assumptions around cross-platform engines and web-app delivery had settled in. The engineering challenge was not merely to write the game once, but to make one codebase behave convincingly across very different stores, operating systems and pieces of mobile hardware.
The promotional video
The original promotional video is still online. It is a useful snapshot of the game itself, but also of the mobile-app era in which Stars was built.
What remained
Stars was not a commercial breakout, and that is not the most useful way to measure it now. The project compressed a surprising amount of learning into one small game: natural interaction, C++ portability, graphics programming, animation tooling, physics, content pipelines, store relationships and the discipline of testing on real hardware.
The lesson that stayed most clearly is also the simplest one: thoughtful technology often works best when the technology itself recedes from view. If the player notices the path they want to draw rather than the machinery interpreting it, the machinery is doing its job.