2.1 Table of variables

Variable name	Description	Equivalence	Value
	Server tick rate (Hz)
	Server tick period (s)	()
	Client tick rate (Hz)
	Client tick period (s)	()
	Ping	RTT (s)
	One Way Delay (s)	()

5.1 Midair today

In early 2020 a new independent studio called Vector Z Studios began development for Midair: Community Edition, which was eventually renamed to Midair 2. As of the writing of this article, Midair 2 remains in development.

Also, as of the writing of this article, analysis performed via reverse engineering confirms that Midair 2 uses the same netcode and lag compensation as Midair.

5.2 Claims (quotes)

The provided quotes do not serve any real purpose other than entertainment (or cringe fuel) due to the fact they are grossly overstated, and raise serious questions about the authors credibility. The remarks suggest either a misunderstanding of the facts or a deliberate distortion (i.e. shilling).

8.1 Defining netcode and lag compensation

Netcode is defined as the part of a game’s programming that manages communication between the client (player) and the server.

Lag compensation is defined as the techniques used to reduce the perceived effect of network latency (i.e. ping).

In the gaming community, these terms are often confused, however they represent two very different concepts and should NOT be used interchangeably.

8.2 Predicting the location of moving objects

8.2.7 When does error minimisation prediction work

Obviously the error minimisation prediction derived above works to an acceptable degree (in regards to accuracy) if a player maintains constant velocity (i.e. zero acceleration) for server ticks since the last server update on the client.

This can be further explained using plots - where the location is mapped to an arbitrary sinusoidal function (which has the properties of having both non-constant velocity and acceleration).

The plot below shows a players position both server side and client side (for varying amounts of RTT ping) when no lag compensation is applied.

As the ping increases, so too does the lag between the server side (real) player position and client side (local) player position.

Next, we apply the error minimisation prediction as our form of lag compensation.

The client side player position (predicted) is nowhere near accurate to the server side (real) player location when the acceleration is non-zero. Conversely, we can clearly see that the client side player position (predicted) is relatively accurate to the server side (real) player location when the acceleration is near zero.

9.1 Server hosting

Any analysis performed must require an isolated Midair server for our client to connect to. As Midair never shipped with any server hosting tools, this functionality must be developed independently through reverse engineering and/or any other techniques.

This process is outside the scope of this investigation and will be omitted.

9.2 Server side player position recording and playback

To gather consistent and accurate data a server side mod must be developed to simulate player movement. Essentially, the player will move in a preset path so we can conduct our analysis accordingly.

This process is outside the scope of this investigation and will be omitted.

9.3 Identifying the existing mechanisms for lag compensation in the Midair client

The Midair client uses a console command to set the degree of lag compensation to perform. This console command is called Predict. It’s usage is documented as follows: Predict <value> (i.e. Predict 160).

Once player position playback is running server side, the Predict value can be varied to see the effects of lag compensated player position on the client.

10.1 Replaying a set path with varying Predict values

Choosing an arbitrary axis (X in this case) and replaying a set path for varying Predict values produces the results as shown below. As the predict value increases we see the error decrease. A key thing to note however is that in this image the position appears to be almost linear, which is why this prediction appears to be working well.

10.2 Setting up for a linear regression

Assume that the predicted position can be expressed as a linear function of the initial position and initial velocity multiplied by a scalar related to Predict ().

where

Rearrange the equation as follows

Let so our velocity scalar () will be computed in milliseconds.

A plot of this equation is provided below.

10.3 Performing a linear regression

Simply apply the OLS (Ordinary Least Squares) method for linear regression.

Representing the results above in tabular form we can see that .

Predict value	Regression slope ()	Regression slope Predict value
40	19.95	0.50
80	40.65	0.51
120	64.66	0.54
160	79.09	0.49

The difference equation for the client can now be expressed as

where

given

constrained by

Now, for the case where ,

11.1 Analysing lag compensation

float __thiscall AMAPlayerController::GetPredictionTime(AMAPlayerController *this)
{
  float Ping;
  ENetMode EVar2;
  float PredictionTime;
  
  EVar2 = AActor::InternalGetNetMode((AActor *)this);
  if ((EVar2 != NM_Standalone) && (this->_padding_ != 0))
  {
    Ping = this->SmoothedRTT;
    PredictionTime = 0.0;
    if ((0.0 <= Ping) && (PredictionTime = this->MaxPredictionPing * 0.001, Ping <= PredictionTime))
    {
      PredictionTime = Ping;
    }
    return PredictionTime * 0.5;
  }
  return 0.0;
}

void __thiscall AMAPlayerController::ServerNegotiatePredictionPing_Implementation (AMAPlayerController *this,float NewPredictionPing)
{
  float MaxPredictionPing;
  
  pUVar1 = UMAGameEngine::GetPrivateStaticClass();
  pUVar2 = pUVar1->ClassDefaultObject;
  if (pUVar2 == NULL)
  {
    (**(code **)(pUVar1->_padding_ + 0x358))(pUVar1);
    pUVar2 = pUVar1->ClassDefaultObject;
  }
  MaxPredictionPing = 0.0;
  if ((0.0 <= NewPredictionPing) && (MaxPredictionPing = *(float *)(pUVar2 + 0x5b), NewPredictionPing <= *(float *)(pUVar2 + 0x5b )))
  {
    MaxPredictionPing = NewPredictionPing;
  }
  this->MaxPredictionPing = MaxPredictionPing;
  return;
}

void __thiscall AMACharacter::MAUpdateSimulatedPosition(AMACharacter *this,FVector *param_1,FRotator *param_2)
{
  float PredictionTime;
  ...

    if (this->MACharacterMovement != NULL)
    {
      pbVar2 = (byte *)((longlong)&this->MACharacterMovement->_padding_ + 7);
      *pbVar2 = *pbVar2 | 0x20;
      PredictionTime = UMAGameplayStatics::GetCatchUpTime((AActor *)this); // Same as calling GetPredictionTime
      if (0.0 < PredictionTime)
      {
        (**(code **)(this->MACharacterMovement->_padding_ + 0x910)) // Same as calling UMACharacterMovement::SimulateMovement
                  (this->MACharacterMovement,PredictionTime);
      }
    }
  ...
}

11.2 Analysing netcode

I won’t waste my time going into a deep explanation of my findings regarding Midairs “custom tailored” netcode. Midair uses stock UE4 netcode. If there were any modifications made to the netcode, their impact is practically negligible. In fact, contextually, Midair did not require any modifications to the netcode in the first place to perform at an acceptable benchmark.

A quote from an ex-Midair 2 developer confirms this.

netcode is mostly just stock ue netcode iirc

- Implosions (Ex-Midair 2 developer) on August 2, 2025

All videos I could find involving Archetype Studios developers which mentioned the application of their custom netcode actually referred to their lag compensation system. As mentioned in Section 8.1, these two terms are NOT interchangeable.

12.1 Prediction

Already covered fairly extensively above.

12.2 Fake projectiles

Fake projectiles (also called client-side predicted projectiles) are visual-only representations of projectiles spawned immediately on the shooter’s client when they fire, before the server confirms the shot.

The server runs its own authoritative simulation of the projectile separately. The client’s projectile is “fake” because it doesn’t determine hit results - it just exists to mask latency.

12.3 How good is Midairs lag compensation?

At low pings (30ms or under), it’s fine. As the ping increases, the game state on the client becomes more and more inaccurate. The use of fake projectiles mask the perceived latency resulting in a placebo effect regarding the efficacy of the lag compensation.

12.4 How does it compare to Tribes titles

It’s basically the same functionality as PFT (Predict Forward Time) from Starsiege: Tribes and Interpolate from Tribes 2, just a smoother implementation (the player models do not teleport/warp as much during prediction thanks to what’s happening under the hood in UE4). This smoother implementation comes at the obvious cost of updating large positional changes slowly, which results in (unnoticeable) desync.

Tribes: Ascend has no form of lag compensation.

Tribes 3: Rivals uses a similar but more complete implementation that provides better overall results with the occasional non-reg at higher pings (again, due to unnoticeable desync).

13.1 Server-side rewind

Server-side rewind (also called lag compensation via history buffers) is the industry standard approach. Rather than guessing where a player will be in the future on the client, the server maintains a rolling history of every player’s position over recent time. When a client fires a shot and the server receives that input, the server rewinds world state back to the moment the client fired (accounting for ping), evaluates the hit against that historical snapshot, and then restores the present state.

14.1 How did this happen?

The straightforward answer is cronyism - and it is almost inevitable in communities built around dead or dying franchises.

In a healthy consumer relationship, there is distance between the developer and the audience. Critics can be critical. Players can be skeptical. A bad product receives honest feedback. In a community-developed successor project, that distance does not exist. Criticising the game means criticising your friends in a community you depend on for social belonging. Skepticism about the netcode means implicitly questioning Mabel, who everyone knows personally and who is generally liked and hailed as a “genius”. The social cost of honest scrutiny is high, and the reward is low - so almost nobody does it.

This dynamic allowed a simple pattern to persist for years: one person made a technically impressive-sounding claim, people who trusted that person repeated it, and the repetition created the appearance of consensus.

In Midair 2, of which the development includes several people who were part of or adjacent to the original Archetype Studios circle, repeated these same claims years after the original game had shut down . This is not coincidental. The same cronyist dynamic that shielded the original claims from scrutiny carried them forward intact into the successor project, where they continue to circulate today.

It is worth being clear: this is not a phenomenon unique to Midair. It is the default mode of operation for community-developed successors to niche dead franchises. The Tribes community is simply a particularly well-documented example of it.

15.1 Midair community

Unsurprisingly, the response from the Midair community has been overwhelmingly negative towards the findings this article. I won’t bother to include quotes of the numerous cringe inducing responses because the authors are clearly deranged.

It seems Mabel slander will not be tolerated… despite the fact he deliberately misled a community that trusted him. Or, perhaps they just can’t handle the fact the game they cherish so much is a dead, technically mediocre product built on borrowed code and propped up by years of unchallenged myth.

15.2 Vector Z Studios

1. Midair was retired from the steam store weeks after the posting of this article
2. The development team has begun implementing their own attempt at server-side rewind solution for Midair 2

16.1 Failure to deliver Kickstarter goals

As mentioned in Section 5, Midair was initially funded using Kickstarter, which listed “Custom Tailored Networking” as one it’s features.

Now that the game has released and been abandoned, let’s take a look at the list of features the Kickstarter promised, and which (if any) features were delivered.

Archetype Studios raised $128,416 via Kickstarter and didn’t really seem to deliver on anything they said they would.

16.2 Over $500,000 of combined sales and funding

A quote from the Co-Founder/CFO/COO of Archetype Studios LinkedIn page is presented below.

// Co-founded an independent game studio of 23 volunteers/paid employees; primary role in finance and business operations, including Marketing, Legal, and HR. Combined sales and funding over $500,000.

Allen Kuceba (Co-Founder/CFO/COO of Archetype Studios)

An internal source to Archetype Studios has alluded to management closing the Kickstarter early once they had raised a large enough sum of funding and obtained external funding. This raises serious questions about the integrity of the campaign considering they could barely accomplish a single Kickstarter goal let alone even ship a functional product.