A binary Swift package. Start it once, open the reporter from your own button, and every report carries a native screenshot, a wireframe replay of the last seconds, console, the trail of screens and device. Network capture is off until you turn it on. On tvOS it reports crashes and errors; there is no on-device reporter.
Three steps
1Add the package — both products
// Package.swift
.package(url: "https://github.com/scriptx-com/everframe", from: "1.2.1")
// link the Everframe AND EverframeReporterUI products
// or CocoaPods
pod 'Everframe'
pod 'Everframe/ReporterUI'
2Start it once, and install the reporter
import EverframeKit
import EverframeReporterUI
EFReporterPresenter.installResolver() // once, at launch
try Everframe.shared.start(
config: EverframeConfig(sdkKey: "evf_live_…") // your SDK key
)
3Open it from your own button
Task {
let result = try await Everframe.shared.report.open()
} What it captures
Screenshot A native capture of exactly what UIKit or SwiftUI drew, with the reporter's annotations no screen-recording prompt
Session replay Wireframe timeline of what the app rendered — layout and real text, not pixels no permission, no video file
Console Last 100 console lines capture.logs, on by default
Network Requests with status and duration, on URLSessions you build with networkCaptureConfiguration() opt-in per session; bodies are a separate per-app gate
Screens UIKit pushes and presentations recorded automatically; SwiftUI screens in one line each
Focused component Not captured on iOS today — the screenshot and the screen trail carry the context
Errors Errors you catch and pass to captureException, with severity, context and metadata capture.crash, on by default
Crash reports Native crashes on iPhone, iPad and Apple TV — Swift traps, uncaught NSExceptions and fatal signals — sent on the next launch capture.crash, on by default
Memory and watchdog kills Foreground out-of-memory and watchdog kills, inferred on the next launch, without a stack
Device and app Model, OS version, screen, locale, timezone, app version
What you wire yourself
- The trigger. No floating bubble; your own button calls report.open(). Without EFReporterPresenter.installResolver() at launch, open() throws.
- Network capture, if you want it: build the URLSession with Everframe.shared.networkCaptureConfiguration(), and set CaptureConfig(network: true) if you also want bodies.
- Sensitive views. Mark them and they are masked before the screenshot leaves the device.
- SwiftUI screen names, one line per screen; UIKit needs nothing.
When to pick it
Native iPhone, iPad and Apple TV apps, UIKit or SwiftUI. Start it in the app delegate, keep your own button, and the SDK handles capture, signing and delivery. React Native apps take the React Native SDK instead; it wraps this one.
What is native about it
The screenshot is a native render of the current window, so it needs no screen-recording permission and includes nothing the app cannot see. Replay is a wireframe timeline of the view hierarchy — layout and real text, deliberately not pixels — which is why it is silent and small. UIKit navigation is recorded automatically; SwiftUI has nothing to observe, so each screen is one line, covered in screen tracking.
On Apple TV
The same package runs on tvOS, but nothing is typed on the television and there is no on-device reporter. Crashes, memory kills and the errors your app passes to captureException are reported on their own. On a linked test Apple TV, holding Play/Pause files a quick capture with the screenshot, replay and logs. The tvOS page has the details, and tvOS crash logs covers what Xcode, TestFlight and a paired Apple TV give you without an SDK.
Before you add it
SDK for mobile apps: what one is and what it costs you covers what any SDK adds to a binary in size and setup, and the deprecation risk that comes with it.
Questions
Does one SDK cover iPhone, iPad and Apple TV?
Yes. The same package targets iOS, iPadOS and tvOS 15 and later, producing the identical envelope on each. On tvOS there is no on-screen reporter: crashes and errors are reported on their own.
How is it distributed?
As a binary via Swift Package Manager from the public scriptx-com/everframe repository, with a CocoaPods pod as well.
Why is network capture off by default?
So a report never carries request data you did not decide to send. Only URLSessions built with Everframe.shared.networkCaptureConfiguration() are captured — URLSession.shared never is; request and response bodies are a separate per-app switch.
