You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
iOS support isn't a priority at the moment, since on average iOS devices performance is much better (and usually that translates to apps having less performance issues).
However it is still something we want to search into and implement at some point, so if you'd like to have iOS support, feel free to show it by adding a 👍 emoji to this issue.
Reacted by Louis Lecocq, Dan Petre, Daniel Reichhart, Vitor Oliveira, Hocine Moukaideche, Matthew Turner, Rahul Krishna, Thuyen Phan, Philip Lindberg, Lie Albert Januar Linarco and 69 more
On iOS, we haven't investigated much a technical solution yet.
For the performance measuring part, I think one possibility would be to use xctrace (previously XCode instruments) to generate a trace file, and then manage to parse it to get an array of measures out of it
If you'd like to try your hand at a POC, I'd be happy to help out!
How can I help contribute to this effort? I'd like to know what are the technical challenges: is it building the perf app in iOS, or is it installing it on a device (idb hurdle), or something else?
Sorry it took so long for me to answer this, it's a good idea to sum up a bit where we're at at the moment!
Sadly, things are not as easy as on Android, where we can just openly read values from system files.
There are 3 elements that are part of the Flashlight philosophy for Android which are tricky to get on iOS:
live measures with flashlight measure
thread by thread measures
blackbox measures (as in: no in-app setup required, can work on production apps)
We have a few approaches that we've tried but are not entirely satisfied with, (and it's also a challenge to dedicate resources to this on our side.)
1st approach: Instruments CLI
❌ Live measures
✅ Thread by thread measures
✅ Blackbox measures
On iOS, Instruments is the usual tool used for performance measures. It's in my opinion very adequate and technically ticks all the boxes above.
However, it's not necessarily easy to use and doesn't offer an easy comparison view.
Instruments however offers a CLI that we can use. Sadly, that CLI doesn't offer live measures. It's also not super easy to use, but @GuillaumeEgret did a fantastic job researching and parsing the output.
It's not totally done still, and there's still this PR open to get it merged that we need to get back to.
2nd approach: using py-ios-device
✅ Live measures
❌ No thread by thread measures
✅ Blackbox measures
Several people have already tried to do something similar and capture live measures with their own tools. One such tool is https://github.com/YueChen-C/py-ios-device. Essentially those tools can behave just like Instruments would and talk with the app to get the same data.
The way to create such a tool is basically by reverse engineering Instruments and it's not an easy task by any mean. The protocols used by Instruments to communicate with the app is reaaaally not straightforward 😅
Unfortunately thread by thread measures seem quite hard to achieve with such a tool.
We do have a POC here which should be working, although we haven't tested it in a while 😬
3rd approach: create a plugin to install in the measured app
✅ Live measures
✅ No thread by thread measures
❌ Blackbox measures
We install an SDK in your iOS app, which can get all relevant data, and communicate that data to Flashlight via websocket. We haven't explored yet what is possible, but it seems we could get out of the box live measures and thread CPU measures.
It generally seems simpler to implement and easier to maintain, however we lose the blackbox aspect:
we need to install an SDK in the app, which shouldn't be published with the app to the appstore
On the other hand, it's much simpler to have quick feedback on what we implement, even if it's in dev mode
In general, my current point of view is I feel like maybe we should reconsider the 3rd approach to see what we can do!
Feel free to jump in the conversation and share your point of view, or just add an emoji 1️⃣, 2️⃣, 3️⃣ to notify which option you'd rather have.
If you'd like to try your hand at implementing one option, or have another idea in mind, let me know and I can help out!
I'll also try to restart that conversation with the RN community as well before the end of the month
Previously, I wouldn’t have chosen 1️⃣ as my go-to, as I loved using Flashlight for live measurements. Recently, however, I’ve started using Flashlight to create performance reports, and it’s been working well for me. I’m also leaning towards 1️⃣ now because it provides thread-by-thread and black-box measurements, which offer a more streamlined developer experience when debugging performance issues
I'd choose 1️⃣ as this is currently working for the CPU metric. Option 2️⃣ does not work on the simulator with iOS 18+ and requires more configuration.
Nope, I really care about this. Combining Flashlight with Maestro to create an automation performance pipeline that supports both iOS and Android is great.
Activity
developerdanx commentedon May 12, 2023
How can we help with iOS support?
Almouro commentedon May 15, 2023
Thanks for asking @developerdanx!
On iOS, we haven't investigated much a technical solution yet.
For the performance measuring part, I think one possibility would be to use
xctrace(previously XCode instruments) to generate a trace file, and then manage to parse it to get an array of measures out of itIf you'd like to try your hand at a POC, I'd be happy to help out!
developerdanx commentedon May 15, 2023
Yes this is feasible I think. I'll try something out and share the results 😁
GuillaumeEgret commentedon Jun 12, 2023
Hi ! Quick update, we are also going to try to develop a POC for iOS in the next few days with @Almouro
Almouro commentedon Jun 29, 2023
We've deployed the (crude) POC here https://github.com/bamlab/flashlight/tree/main/packages/ios-poc
We'll work to make it easier to use in the coming weeks with @GuillaumeEgret 🤞
Almouro commentedon Sep 14, 2023
Still in progress, but @GuillaumeEgret managed to have a POC of CPU measures per thread when running a Maestro test
It's already running in the CI on this repo https://github.com/bamlab/flashlight/blob/main/.github/workflows/ios_e2e.sh
Here's an example report: https://65031abea84fdb098fb48ce4--flashlight-open-source-reports.netlify.app/report.html
Next is:
flashlight teston Androidflashlight measureJuanRdBO commentedon Apr 11, 2024
Hey guys! Is this still ongoing? I'd love to test iOS devices as well
alaz-aura commentedon Jul 17, 2024
+1 to see if this iOS support is still in development
anton-patrushev commentedon Jul 19, 2024
hey everyone 👋
do you have any updates for iOS support?
cc: @Almouro
samholmes commentedon Aug 6, 2024
+1 for this too.
How can I help contribute to this effort? I'd like to know what are the technical challenges: is it building the perf app in iOS, or is it installing it on a device (idb hurdle), or something else?
Almouro commentedon Sep 6, 2024
Sorry it took so long for me to answer this, it's a good idea to sum up a bit where we're at at the moment!
Sadly, things are not as easy as on Android, where we can just openly read values from system files.
There are 3 elements that are part of the Flashlight philosophy for Android which are tricky to get on iOS:
flashlight measureWe have a few approaches that we've tried but are not entirely satisfied with, (and it's also a challenge to dedicate resources to this on our side.)
1st approach: Instruments CLI
❌ Live measures
✅ Thread by thread measures
✅ Blackbox measures
On iOS,
Instrumentsis the usual tool used for performance measures. It's in my opinion very adequate and technically ticks all the boxes above.However, it's not necessarily easy to use and doesn't offer an easy comparison view.
Instrumentshowever offers a CLI that we can use. Sadly, that CLI doesn't offer live measures. It's also not super easy to use, but @GuillaumeEgret did a fantastic job researching and parsing the output.It's not totally done still, and there's still this PR open to get it merged that we need to get back to.
2nd approach: using
py-ios-device✅ Live measures
❌ No thread by thread measures
✅ Blackbox measures
Several people have already tried to do something similar and capture live measures with their own tools. One such tool is https://github.com/YueChen-C/py-ios-device. Essentially those tools can behave just like Instruments would and talk with the app to get the same data.
The way to create such a tool is basically by reverse engineering Instruments and it's not an easy task by any mean. The protocols used by Instruments to communicate with the app is reaaaally not straightforward 😅
Unfortunately thread by thread measures seem quite hard to achieve with such a tool.
We do have a POC here which should be working, although we haven't tested it in a while 😬
3rd approach: create a plugin to install in the measured app
✅ Live measures
✅ No thread by thread measures
❌ Blackbox measures
We haven't explored this approach a lot, but coming back to it might be a good idea.
The idea would be to have something similar to https://github.com/bamlab/react-native-flipper-performance-monitor
We install an SDK in your iOS app, which can get all relevant data, and communicate that data to Flashlight via websocket. We haven't explored yet what is possible, but it seems we could get out of the box live measures and thread CPU measures.
It generally seems simpler to implement and easier to maintain, however we lose the blackbox aspect:
On the other hand, it's much simpler to have quick feedback on what we implement, even if it's in dev mode
In general, my current point of view is I feel like maybe we should reconsider the 3rd approach to see what we can do!
Feel free to jump in the conversation and share your point of view, or just add an emoji 1️⃣, 2️⃣, 3️⃣ to notify which option you'd rather have.
If you'd like to try your hand at implementing one option, or have another idea in mind, let me know and I can help out!
I'll also try to restart that conversation with the RN community as well before the end of the month
bvoq commentedon Sep 30, 2024
Maybe 1️⃣ together with a video recording?
We use it mostly with maestro tests at the moment.
MalcolmTomisin commentedon Oct 31, 2024
Previously, I wouldn’t have chosen 1️⃣ as my go-to, as I loved using Flashlight for live measurements. Recently, however, I’ve started using Flashlight to create performance reports, and it’s been working well for me. I’m also leaning towards 1️⃣ now because it provides thread-by-thread and black-box measurements, which offer a more streamlined developer experience when debugging performance issues
roni-castro-shipt commentedon May 28, 2025
I'd choose 1️⃣ as this is currently working for the CPU metric. Option 2️⃣ does not work on the simulator with iOS 18+ and requires more configuration.
henry-dorsia commentedon Sep 3, 2025
any updates on this ? I only have an iOS app. Xcode instruments is unusable and this would be great to have
bouthouri commentedon Nov 2, 2025
Is there any update? Maybe something planned for 2026 "Hopefully"?
Bowlerr commentedon Dec 3, 2025
Any new updates on this? (+1)
TacticCoder commentedon Dec 22, 2025
Any updates on this one ?
pedrobzz commentedon Feb 16, 2026
so, no one cares anymore, right?
vu-nd commentedon May 28, 2026
Nope, I really care about this. Combining Flashlight with Maestro to create an automation performance pipeline that supports both iOS and Android is great.
techgig17 commentedon Aug 4, 2026
Any updates?