Services

Everything between an idea and a live store listing.

Six things we do. Most projects use three or four of them — you don't have to buy the whole list, and we'll tell you which ones you actually need.

01 — Game development

Games that feel right on the device they're on.

We build in Unity when the project wants portability and native when it wants performance or platform integration. Either way the work goes past gameplay: input handling, controller support, save systems, achievements, and the store SDK plumbing that always takes longer than anyone budgets for.

  • Prototype-first development — playable in weeks, not quarters
  • Unity, C#, Swift, and Metal for performance-critical paths
  • Controller, touch, and keyboard input with proper remapping
  • Game Center, iCloud, and Microsoft Store service integration
  • Frame-time profiling and memory work on real target hardware
02 — App development

Native apps that fit their platform.

A Mac app should feel like a Mac app. We write SwiftUI and AppKit on Apple platforms, WinUI 3 and .NET on Windows, and share a core in Rust or C# only where sharing actually saves time rather than creating a second problem.

  • SwiftUI, AppKit, and UIKit across iOS and macOS
  • WinUI 3, WPF, and .NET for Windows desktop
  • Offline-first data, sync, and conflict resolution
  • System integration — widgets, share sheets, shortcuts, notifications
  • Accessibility and keyboard navigation treated as requirements
03 — Porting & platform expansion

One product, more storefronts.

You have something working on one platform and want it on another. We handle the port — not a lazy wrapper, but a build that respects the conventions of the destination and passes its review process on the way in.

  • iOS → macOS, iPhone → iPad, mobile → desktop
  • Input and UI re-work for the target's interaction model
  • Platform-specific entitlements, sandboxing, and signing
  • Honest assessment first — we'll say if a port isn't worth it
04 — Product design

Design that survives contact with engineering.

We design in the same room as the build, so what gets drawn is what gets shipped. That means fewer beautiful mockups that quietly become impossible and more decisions made while they're still cheap to change.

  • Product and interaction design for apps and games
  • UI systems, component libraries, and design tokens
  • Store assets — icons, screenshots, preview videos
  • Onboarding and first-run flows, where most installs are lost
05 — Store release management

The part everyone underestimates.

Certificates, provisioning profiles, entitlements, age ratings, privacy nutrition labels, export compliance, and a reviewer who rejects the build for a reason nobody can find in the guidelines. We've done this enough times to know where it goes wrong.

  • App Store Connect and Microsoft Partner Center setup
  • Signing, notarisation, and entitlement configuration
  • Listing copy, keywords, and screenshot sets per platform
  • Review rejections handled and resubmitted — usually same week
  • Staged rollouts and TestFlight or closed-beta programmes
06 — Live ops & support

Launch is the middle, not the end.

Operating systems move every year and a shipped product that nobody maintains quietly stops working. A retainer keeps yours current — and keeps someone on call when a crash spike shows up on a Friday.

  • OS version compatibility and annual SDK migrations
  • Crash monitoring, triage, and hotfix releases
  • Feature updates on an agreed monthly budget
  • Store listing health, ratings, and review responses

Common questions

Before you get in touch.

How much does a project cost?

It depends on scope, and anyone who quotes before understanding yours is guessing. Most engagements start with a short paid discovery — typically one to two weeks — which ends with a written scope and a fixed number. If you don't like the number, you own the discovery document and can take it elsewhere.

Do you work with existing codebases?

Often. We'll start with a paid technical audit rather than promising anything sight-unseen. If the honest answer is that a rewrite costs less than a rescue, we'll tell you that even though it's the less comfortable conversation.

Who owns the code?

You do — source, assets, store credentials, and signing certificates, all transferred at completion. We don't hold anything hostage as leverage for a retainer.

Can you take over a project someone else abandoned?

Yes, and it's more common than you'd think. The audit is non-negotiable in those cases: we need to know what we're inheriting before we can commit to a timeline.

Do you sign NDAs?

Yes, happily, before any detailed discussion. Send yours over or use ours.

Not sure which of these you need?

Describe the problem rather than the solution. We'll tell you what the work actually involves — including when the answer is "less than you think".

Start a conversation Email us directly