TraverseGamesWork with us
Menu

Traverse Games

Unity development

Help for your Unity team with performance, render pipelines, C# and native code, and the tools around them, delivered in your project and build pipeline.

C# / Render pipelines / Native code

Focused support for your production team.

Tell us what needs to move
  • Unity 6 and LTS
  • URP
  • HDRP
  • Custom SRP
  • Burst
  • Job system
  • IL2CPP
  • Addressables
  • Native plugins

01 / Performance

Get the frame back within budget.

A spike on the main thread, garbage-collection hitches or memory that keeps growing between scenes can hold up a release. We work from the Unity Profiler, Memory Profiler and Frame Debugger alongside platform GPU captures to find the limiting work, then implement and measure the change in your project.

On mobile that includes the long tail of devices your players actually use, with frame pacing, thermals and build size measured alongside frame time.

Our approach to mobile performance

02 / Rendering

Make the render pipeline fit your game.

We work in the Universal and High Definition Render Pipelines and in custom Scriptable Render Pipeline code. That covers renderer features and custom passes, lighting and shadows, shader variants and their effect on build size and load times, and the batching behind draw-call cost.

When a project needs to move between pipelines, for example from HDRP to URP to reach more devices, we plan the move with your art and technical leads and carry the visual target across.

Our rendering and graphics work

03 / Code

Fast C#, and native code where it pays.

We move hot paths to Burst and the job system, cut allocations that feed the garbage collector, and check what IL2CPP generates for the code that matters. Data layout changes often help more than micro-optimisation, so we start there.

Where C# is not enough, we write native plugins in C++ or Rust for Android, iOS, desktop and console, with the interop and build integration your team needs to maintain them.

04 / Tools & pipelines

Tools, content pipelines and builds.

We build editor tools, import and build-time processing, and Addressables setups for streaming and download size. The aim is faster iteration for your artists and designers and builds that behave the same on every machine.

We check how the work builds and packages on each target platform and keep it inside your existing build automation.

Extra engineering capacity for the work that is holding you up

Your team may be balancing feature work, performance targets, platform issues and an upgrade that keeps slipping. We can take on a focused investigation, own a defined feature or tool, or work alongside your engineers on a wider rendering or performance task.

Start with your Unity version, the render pipeline you use, the target platforms and the thing your team needs to move forward. We agree a concrete outcome and a way to review it before the work expands.

Built in your project, reviewed by your team

Our engineers work in your repositories, against your build automation and through your review gates. Work is tracked in your Jira and discussed in your Slack. Your technical leads talk directly to the people writing the code.

You receive reviewable commits, runnable builds and the context needed to maintain the result. For performance work that includes repeatable captures; for rendering, the agreed visual target on each device tier; for tools and native code, the integration and platform considerations.

Talk through the work your team needs or see how an engagement runs.

A few useful answers.

Do you need Unity source access?

No. Most of the work happens in your project code, render pipeline packages and native plugins. If your studio licenses Unity source, we can work there too.

Which Unity versions do you work with?

Unity 6 and recent LTS releases. Tell us your version and how far your packages have been customised; that shapes the upgrade discussion.

Can you help us move from HDRP to URP?

Yes. We agree the visual target and device range with your leads, then plan which features carry over, which need a different approach and how to keep the game shippable during the move.

Can you take on a custom rendering feature in Unity?

Yes. A renderer feature or custom pass that the pipeline does not provide is the kind of work our rendering engineers do. We prototype it in your project first.

Can you help with garbage-collection hitches and memory growth?

Yes. We find where allocations and retained memory come from with the Unity profilers, then change the code and data so they stop, and measure the result on your target devices.

Can you work with a weekly release cadence?

Yes. Changes land through your branches, review gates and release train, sized so they can ship in a normal update.

Traverse Research + Traverse Games

Let’s turn a good question into working software.

Start a conversation