Listen to this Post
Introduction:
Gravitational chaos meets elegant design in the newly updated By‑Pass iOS app (version 1.5, currently under Apple review), which simulates real‑time N‑body gravity using symplectic Euler integration and a futuristic Liquid Glass HUD inspired by iOS 26 design principles. While the app itself is a physics sandbox, its underlying techniques—real‑time trajectory prediction, chaotic system visualization, and efficient SpriteKit rendering—offer valuable lessons for developers building high‑performance simulation tools, game engines, or even security‑related anomaly detection systems that model unpredictable behaviors.
Learning Objectives:
- Understand how symplectic Euler integration preserves energy in gravitational simulations compared to naive Euler methods.
- Learn to implement real‑time orbit previews and handle multi‑body systems where closed‑form solutions don’t exist.
- Explore iOS development patterns for non‑blocking UI (Liquid Glass HUD), screen capture APIs, and performance optimization using SpriteKit.
You Should Know:
1. Symplectic Euler Integration for Stable Orbits
Naive Euler integration quickly causes artificial energy drift, making satellites spiral into stars erroneously. Symplectic Euler (semi‑implicit Euler) updates velocity first, then position, conserving energy over long simulations. Below is a Swift implementation snippet used in By‑Pass:
struct Body {
var position: CGPoint
var velocity: CGVector
var mass: CGFloat
}
func symplecticEuler(body: inout Body, acceleration: CGVector, dt: CGFloat) {
// Update velocity first (semi‑implicit)
body.velocity.dx += acceleration.dx dt
body.velocity.dy += acceleration.dy dt
// Then update position
body.position.x += body.velocity.dx dt
body.position.y += body.velocity.dy dt
}
func computeAcceleration(for body: Body, from others: [bash], G: CGFloat) -> CGVector {
var accel = CGVector.zero
for other in others {
let dx = other.position.x - body.position.x
let dy = other.position.y - body.position.y
let distSq = max(dxdx + dydy, 1e-6)
let dist = sqrt(distSq)
let forceMag = (G body.mass other.mass) / distSq
let accelMag = forceMag / body.mass
let dirX = dx / dist
let dirY = dy / dist
accel.dx += accelMag dirX
accel.dy += accelMag dirY
}
return accel
}
Step‑by‑step guide to integrate symplectic Euler in your own iOS project:
1. Create a `SKScene` subclass and maintain an array of `Body` objects.
2. Override `update(_ currentTime:)` to compute net acceleration on each body from all others (O(N²) complexity – consider spatial partitioning for >100 bodies).
3. Call `symplecticEuler` for each body with a fixed timestep (e.g., dt = 1/60.0).
4. Update `SKSpriteNode` positions to match simulated positions.
- For the orbit preview (when placing a new satellite), run the same integrator forward for ~300 steps without rendering to draw a translucent predicted path.
2. Handling the 3‑Body Problem Without False Predictions
Klaus intentionally disabled orbit preview in multi‑star mode because the three‑body problem is chaotic—small initial condition changes lead to exponentially diverging trajectories. A naïve preview would give users false confidence. Instead, By‑Pass relies on real‑time visualization without predictive assistance. This design choice teaches a critical lesson: never over‑predict when your model’s uncertainty exceeds the perceived benefit.
Step‑by‑step for implementing conditional orbit preview:
- Detect number of massive bodies (stars) – if >2, set
orbitPreviewEnabled = false. - For single‑star mode, use symplectic Euler to compute future positions for the satellite being dragged.
- Draw the predicted path using `UIBezierPath` or `SKShapeNode` with low alpha.
- In multi‑star mode, either show no preview or show a “chaotic zone” indicator (e.g., animated static lines).
- Liquid Glass HUD – A New iOS 26 Design Pattern
The update removes tab bars and places semi‑transparent glass buttons in screen corners. This maximizes screen real estate for physics visualization. To replicate this in SwiftUI or UIKit:
import SwiftUI
struct LiquidGlassButton: View {
let systemImage: String
let action: () -> Void
var body: some View {
Button(action: action) {
Image(systemName: systemImage)
.font(.title2)
.foregroundStyle(.white)
.padding(12)
.background(.ultraThinMaterial)
.clipShape(Circle())
.shadow(color: .black.opacity(0.2), radius: 5, x: 0, y: 2)
}
}
}
// In your main view
ZStack {
SimulationView()
VStack {
HStack {
LiquidGlassButton(systemImage: "camera.fill") { takeScreenshot() }
.padding(.top, 50)
.padding(.leading, 20)
Spacer()
LiquidGlassButton(systemImage: "record.circle") { startRecording() }
.padding(.top, 50)
.padding(.trailing, 20)
}
Spacer()
}
}
Step‑by‑step for implementing Liquid Glass HUD:
- Use `.ultraThinMaterial` or `.thinMaterial` for backgrounds.
- Apply `ZStack` to overlay controls on top of your `SKScene` or Metal view.
- For long‑press detection on buttons (to start screen recording), attach a `LongPressGesture` modifier.
- Ensure touches pass through transparent areas by setting `UIView`
isUserInteractionEnabledappropriately.
4. Screen Capture and Recording – Programmatic Implementation
By‑Pass allows screenshots via tap and screen recording via long press on the camera button. This uses iOS’s `UIGraphicsImageRenderer` and ReplayKit. Below is a complete example:
import UIKit
import ReplayKit
class CaptureHelper {
let recorder = RPScreenRecorder.shared()
func takeScreenshot(of view: UIView) -> UIImage {
let renderer = UIGraphicsImageRenderer(size: view.bounds.size)
return renderer.image { ctx in
view.drawHierarchy(in: view.bounds, afterScreenUpdates: true)
}
}
func startRecording(completion: @escaping (Error?) -> Void) {
guard recorder.isAvailable else {
completion(NSError(domain: "Recorder", code: 1, userInfo: nil))
return
}
recorder.startRecording { error in
completion(error)
}
}
func stopRecording(previewController: UIViewController) {
recorder.stopRecording { preview, error in
if let preview = preview {
preview.previewControllerDelegate = previewController as? RPPreviewViewControllerDelegate
previewController.present(preview, animated: true)
}
}
}
}
Step‑by‑step integration:
- Add `Privacy – Microphone Usage Description` and `Privacy – Camera Usage Description` to Info.plist even if only recording screen (Apple requires it).
- For long press, use `UILongPressGestureRecognizer` with minimum duration 0.5 seconds.
- Save screenshots to user’s photo library using
UIImageWriteToSavedPhotosAlbum. - ReplayKit recordings automatically prompt user to save or share.
5. Performance Optimization for Real‑Time N‑Body Simulations
With >50 satellites, O(N²) force calculations can drop frame rates. Klaus likely uses SpriteKit’s physics engine or spatial hashing. Here’s a Swift implementation of a simple grid‑based spatial partition:
class SpatialHash {
let cellSize: CGFloat
var grid: [Int: [bash]] = [:]
init(cellSize: CGFloat) { self.cellSize = cellSize }
func hash(for position: CGPoint) -> Int {
let x = Int(floor(position.x / cellSize))
let y = Int(floor(position.y / cellSize))
return (x << 16) ^ y
}
func insert(body: Body) {
let key = hash(for: body.position)
grid[key, default: []].append(body)
}
func neighbors(for body: Body) -> [bash] {
let key = hash(for: body.position)
var result = grid[key, default: []]
// Also check adjacent cells for accuracy (omitted for brevity)
return result
}
}
Step‑by‑step optimization:
- Rebuild spatial hash every frame (O(N) cost).
- Only compute forces between bodies in the same or adjacent cells.
- For iOS, use `simd` floating‑point types for SIMD acceleration.
- Limit maximum number of bodies to ~200 for 60 FPS on iPhone 13 and newer.
What Undercode Say:
- Chaos teaches humility in prediction – By‑Pass deliberately withholds orbit previews in chaotic regimes, a lesson applicable to cybersecurity threat modeling where adversarial actions are inherently unpredictable. Never over‑promise deterministic forecasts in non‑linear systems.
- Energy‑conserving integrators matter – Symplectic Euler prevents artificial decay, analogous to using proper cryptographic state persistence instead of naive resets that leak entropy. Small implementation details determine long‑term stability.
Prediction:
As iOS 26’s Liquid Glass design language matures, more simulation and security apps will adopt floating, context‑aware UIs that fade into the background. The broader trend points toward “invisible interfaces” for AR and physics tools. In cybersecurity, expect real‑time anomaly simulators (e.g., network traffic chaos modeling) to borrow symplectic integration for more accurate long‑term threat trajectory analysis. By‑Pass’s choice to disable predictions in multi‑body systems foreshadows a shift toward honest, uncertainty‑aware AI systems—a critical evolution for both app design and defensive AI.
▶️ Related Video (76% Match):
🎯Let’s Practice For Free:
IT/Security Reporter URL:
Reported By: Kmrkmrkmrkmr By – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
