New iPhone 16e Benchmarks Compared to iPhone 16

This article from Orcacore delves into the new iPhone 16e benchmarks, meticulously comparing its CPU and GPU performance against its sibling, the iPhone 16. Positioned as Apple’s more budget-friendly option, the iPhone 16e enters the market with an attractive $600 price point. Under the hood, it boasts the same powerful A18 chip found in the standard iPhone 16 models. However, a key difference lies in the graphics processing unit (GPU), where the iPhone 16e features one less core. Recent benchmark results shed light on the implications of this design choice, revealing that while the iPhone 16e’s CPU capabilities match the iPhone 16, its GPU performance lags behind.

According to data provided by Geekerwan and reported by Notebookcheck , the iPhone 16e demonstrates CPU performance comparable to the iPhone 16. In Geekbench’s single-core and multi-core tests, the phone achieved scores of 3520 and 9181, respectively. Comparatively, the iPhone 16 secured scores of 3509 and 9018 in the same tests, underscoring the near-identical CPU performance between the two models.

However, the story shifts when examining the graphics processor. The iPhone 16e is equipped with one fewer GPU core than its counterpart. In 3DMark’s WildLife Extreme benchmark, the phone scored 3862, while the iPhone 16 Plus achieved a score of 4588.

In the Nomad Light test, the iPhone 16e also recorded a score of 1627, compared to the iPhone 16 Plus’s 1916.

Initial benchmarks for the iPhone 16e revealed a score of 24,188 points in "Geekbench 6 Metal," falling short of the iPhone 16 and 16 Plus models. This 15% reduction in graphics power could pose a limitation for users demanding high performance in graphically intensive applications and games.

The A18 chip powering the iPhone 16e comprises an 8-core CPU, 4-core GPU, and 16-core Neural Engine. However, the removal of one graphics core translates to a performance reduction of approximately 15% when compared to the iPhone 16 and iPhone 16 Plus. The new iPhone 16e benchmarks highlight this difference.

It is crucial to acknowledge that a more comprehensive suite of tests is necessary for a precise evaluation of the new iPhone 16e benchmarks. Relying solely on the available benchmarks may not paint a complete picture. For users prioritizing graphics performance, especially for demanding gaming or other visually intensive tasks, opting for the iPhone 16 or iPhone 16 Plus might be a more suitable choice.

Conclusion

This article presented an overview of the new iPhone 16e benchmarks. Despite its more accessible price point, the iPhone 16e remains a compelling choice for consumers seeking a well-performing Apple phone at a reduced cost. While its graphics capabilities fall slightly behind those of its higher-end counterparts, the iPhone 16e should adequately meet the needs of the average user who doesn’t require substantial graphics processing power. However, users with aspirations of running resource-intensive games or engaging in activities demanding high graphics processing are advised to consider the iPhone 16 or iPhone 16 Plus models.

Please subscribe to us on Facebook, YouTube, Telegram, and X. Also, you may like to read the following articles:

iPhone 16E Specifications

First Foldable iPhone

iOS 18.3 Update Released

iPhone SE 4 Design Revealed in New Video

iPhone 16 Pro Max vs Samsung Galaxy S25 Ultra

Review New Generation of Apple Studio Display Monitor

Alternative Solutions and Elaboration

While the article focuses on the hardware difference (one less GPU core) and its impact on performance, it doesn’t delve into potential software-level mitigations or alternative approaches to address the GPU performance gap between the iPhone 16e and the iPhone 16. Here are two alternative approaches:

1. Dynamic Resolution Scaling and Adaptive Fidelity:

Instead of simply accepting the lower GPU performance, Apple (or game developers specifically targeting the iPhone 16e) could implement dynamic resolution scaling and adaptive fidelity techniques. These methods dynamically adjust the resolution and visual fidelity of games and applications in real-time, based on the current GPU load. This would allow the iPhone 16e to maintain a smooth frame rate, even in demanding scenes, by automatically reducing the rendering resolution or simplifying visual effects. The iPhone 16, with its more powerful GPU, could maintain a higher resolution and more detailed visuals.

Explanation:

Dynamic resolution scaling involves continuously monitoring the frame rate. If the frame rate drops below a target threshold (e.g., 30fps or 60fps), the rendering resolution is reduced. Conversely, if the frame rate is consistently high, the resolution can be increased. Adaptive fidelity takes a similar approach but focuses on adjusting the quality of individual visual effects, such as shadows, textures, and particle effects. Less important effects can be simplified or disabled entirely to reduce the GPU load.

Code Example (Conceptual – Using a hypothetical game engine API):

# Hypothetical function to get current frame time
def get_frame_time():
  # Returns time taken to render the last frame in milliseconds
  pass

# Target frame rate (e.g., 60 FPS)
TARGET_FPS = 60
TARGET_FRAME_TIME = 1000 / TARGET_FPS # Target frame time in milliseconds

# Initial resolution scale (1.0 = full resolution)
resolution_scale = 1.0

# Minimum resolution scale
MIN_RESOLUTION_SCALE = 0.5

# Maximum resolution scale
MAX_RESOLUTION_SCALE = 1.0

# Function to adjust resolution scale dynamically
def adjust_resolution_scale():
  global resolution_scale
  frame_time = get_frame_time()

  if frame_time > TARGET_FRAME_TIME * 1.1:  # Frame time exceeds target by 10%
    resolution_scale = max(MIN_RESOLUTION_SCALE, resolution_scale - 0.05) # Reduce resolution
    set_resolution(resolution_scale) # Hypothetical function to set the resolution
    print(f"Reducing resolution scale to: {resolution_scale}")
  elif frame_time < TARGET_FRAME_TIME * 0.9: # Frame time is significantly lower than target
    resolution_scale = min(MAX_RESOLUTION_SCALE, resolution_scale + 0.05) # Increase resolution
    set_resolution(resolution_scale)
    print(f"Increasing resolution scale to: {resolution_scale}")

# Hypothetical function to set the rendering resolution
def set_resolution(scale):
  # Engine-specific code to set the resolution based on the scale factor
  pass

# Main game loop (example)
while True:
  # ... game logic ...

  adjust_resolution_scale() # Adjust resolution before rendering

  # ... rendering code ...

This is a simplified example, but it illustrates the core concept. Real-world implementations would be more complex and would likely involve a combination of resolution scaling and adaptive fidelity adjustments. This also puts onus on game developers.

2. Cloud Gaming and Remote Rendering:

Another, more radical, approach is to leverage cloud gaming or remote rendering. In this scenario, the computationally intensive graphics processing is offloaded to a powerful server in the cloud. The iPhone 16e then acts as a thin client, receiving a streamed video feed of the rendered game or application. This would allow the iPhone 16e to run demanding applications that would otherwise be impossible due to its hardware limitations.

Explanation:

Cloud gaming services like NVIDIA GeForce Now and Xbox Cloud Gaming already employ this technology. The game runs on a remote server, and the user interacts with the game through a streamed video feed. The iPhone 16e would only need to be able to decode the video stream and transmit user input (e.g., touch screen gestures, button presses) to the server.

Code Example (Conceptual – Using a hypothetical streaming API):

# Hypothetical Cloud Gaming Client

import network
import video_decoder
import input_handler

# Server address
SERVER_ADDRESS = "cloudgaming.example.com"
SERVER_PORT = 8000

# Connect to the server
connection = network.connect(SERVER_ADDRESS, SERVER_PORT)

# Initialize video decoder
decoder = video_decoder.create_decoder()

# Initialize input handler
input = input_handler.create_handler()

# Main loop
while True:
    # Receive video frame from server
    frame_data = connection.receive_frame()

    # Decode the frame
    frame = decoder.decode(frame_data)

    # Display the frame
    video_decoder.display_frame(frame)

    # Get user input
    user_input = input.get_input()

    # Send user input to the server
    connection.send_input(user_input)

    # Error Handling
    if connection.has_error():
        print("Connection Error")
        break

# Close connection
connection.close()

# In input_handler.py:
# def get_input():
#    if touch_screen.is_touched():
#        return touch_screen.get_touch_position()
#    else:
#        return None

This approach requires a stable and high-bandwidth internet connection. Latency (the delay between user input and the server’s response) is a critical factor, and cloud gaming services employ various techniques to minimize it. While Apple could technically implement their own cloud gaming solution, the current business model of the app store (and cloud gaming generally) may preclude this approach. This type of system could even be integrated into an app for a particular application.

While these approaches don’t directly address the hardware limitation of the iPhone 16e, they offer viable alternatives to improve the user experience and allow the phone to handle more demanding tasks. The decision to implement these strategies would depend on Apple’s overall product strategy and their commitment to providing a consistent experience across their device lineup. The new iPhone 16e benchmarks serve as a crucial data point in determining whether these software-level optimizations are necessary.