From Newsgroup: comp.mobile.android
Developer Gets Real iOS 16 Running on a Xiaomi Redmi Note 12, but There's a Catch
For years, smartphone enthusiasts have tried to make Android phones look like iPhones using custom launchers, icon packs and modified interfaces.
One developer has now taken that idea considerably further by getting Apple's actual iOS operating system to boot on a Xiaomi Redmi Note 12.
And no, this is not another Android theme pretending to be iOS.
A developer known online as Makr has successfully brought the iOS 16.7.16 software environment to the Redmi Note 12 4G, using a modified version of Apple's XNU operating-system kernel.
The experimental project, called ios-topaz, allows the Xiaomi smartphone to display Apple's familiar startup logo and reach the genuine iOS lock screen.
The system even identifies the device as an iPhone X.
The achievement was demonstrated on October 18 and attracted attention across developer communities on October 19, 2026.
However, there is a substantial catch.
Although iOS boots, the Xiaomi phone cannot currently function as an ordinary iPhone.
Cellular connectivity, Wi-Fi, Bluetooth, audio, cameras, GPS and hardware graphics acceleration are all missing.
The operating system also uses only four of the Redmi's eight processor cores, and most of Apple's normal security protections have been disabled to make the experimental port possible.
Nevertheless, the project represents an impressive technical achievement.
Apple designs iOS specifically for its own hardware, with extensive integration between the operating system, processors, drivers and security architecture.
Getting that software to start on an inexpensive Android smartphone requires considerably more engineering than changing a few interface elements.
The developer has published the project's source code, allowing other enthusiasts to examine the work and potentially contribute improvements.
For now, the result is best understood as a proof of concept demonstrating what determined developers can accomplish with hardware and software that were never designed to work together.
Key Facts: iOS 16 on the Redmi Note 12
* Project name: ios-topaz.
* Developer: Makr, also known as MakrSas.
* Smartphone: Xiaomi Redmi Note 12 4G.
* Processor: Qualcomm Snapdragon 685.
* Operating system: Apple iOS 16.7.16.
* iOS build: 20H392.
* Original firmware: iPhone X.
* Kernel: Modified Apple XNU, based on the iOS 16 generation.
* Boot time: Approximately three minutes to the lock screen.
* Device identification: iPhone X.
* Working processor cores: Four out of eight.
* Graphics: Software rendering using the CPU.
* Touchscreen: Driver developed, with functionality still being tested and refined.
* Wireless connections: Not functioning.
* Camera and audio: Not functioning.
* Security features: Mostly disabled or replaced with experimental components. * Project availability: Source code published on GitHub.
* Installation risk: Erases the phone's Android user-data partition.
Most importantly, this is not an official Apple product, an authorized iOS installation or a usable alternative smartphone operating system.
It is an experimental port intended for developers and technically experienced enthusiasts.
This Is Real iOS, Not an Android Launcher or Emulator
The most important distinction is what the developer has actually accomplished.
Android users have long been able to download launchers that imitate Apple's home screen.
Those applications can reproduce familiar icons, navigation elements and visual effects.
Some even imitate the iPhone's Control Center, notifications and lock screen.
However, underneath the appearance, the device continues running Android.
The ios-topaz project works differently.
The Redmi Note 12 boots a version of Apple's XNU kernel adapted to operate on its Qualcomm processor.
On top of that kernel, the developer runs genuine user-space components taken from iOS 16.7.16 for the iPhone X.
These components include SpringBoard, the software responsible for the familiar iPhone interface, and launchd, which manages the starting of system processes.
Additional Apple services are also present.
In other words, the project uses actual iOS software rather than attempting to reproduce its appearance through Android applications.
However, describing the operating system as completely unchanged would be misleading.
The iOS user-space components originate from Apple's firmware, but the kernel and surrounding environment have been extensively modified to work on incompatible hardware.
Some services have been disabled, and alternative implementations have been introduced for functions normally handled by Apple-specific components.
The result is a combination of genuine Apple software and substantial community-developed engineering.
That is why the achievement is interesting.
It demonstrates that selected parts of iOS can execute on non-Apple hardware when developers provide enough of the necessary underlying infrastructure.
It does not establish that the Xiaomi device can run the complete iPhone experience.
Why the Redmi Note 12 Pretends to Be an iPhone X
When the experimental system starts, iOS identifies the Redmi Note 12 as an iPhone X.
This is not because the Xiaomi phone has somehow been transformed into Apple hardware.
The identification is deliberately supplied by the developer's compatibility environment.
Apple uses internal device identifiers to distinguish different iPhone and iPad models.
Those identifiers help the operating system determine which hardware configuration and software behavior it should expect.
The ios-topaz project presents information corresponding to the iPhone X, including the identifier iPhone10,3.
This allows the imported iOS components to operate with a familiar device profile.
The choice of the iPhone X is also practical.
Apple's iOS 16.7.16 firmware for that model provides an established set of system components that can be studied and adapted.
The iPhone X uses a gesture-based interface without a traditional physical Home button, which is useful when attempting to reproduce its interface on another touchscreen smartphone.
However, the identification does not grant access to Apple's hardware security features.
It also does not make the Redmi eligible for ordinary iPhone software updates or official Apple support.
The Xiaomi phone is essentially presenting itself to the operating system as a device whose hardware it does not actually possess.
That discrepancy explains many of the missing features.
iOS expects Apple-specific drivers and components, while the Redmi contains Qualcomm and Xiaomi hardware that requires entirely different software.
The Snapdragon 685 Created a Major Processor Compatibility Problem
One of the biggest challenges involved the Redmi Note 12's processor.
The Snapdragon 685 contains eight CPU cores divided into two groups.
Four higher-performance cores are based on ARM Cortex-A73-class technology.
The remaining four are more energy-efficient Cortex-A53-class cores.
Android is designed to make effective use of this combination.
However, the version of iOS being ported expects a different memory-management configuration.
The difficulty concerns memory pages.
Operating systems divide physical and virtual memory into blocks called pages.
Page size affects how software maps memory, accesses information and manages system resources.
The iOS components used by the developer expect 16-kilobyte memory pages.
Unfortunately, the Redmi's four energy-efficient processor cores do not support the required 16KB translation configuration.
That presented an obstacle before the operating system could even begin running normally.
The developer's solution was to start the operating system using only the four higher-performance cores.
The other four cores remain inactive.
This reduces the amount of processing hardware available to the system, but it allows the required memory configuration to work.
The processor also lacks certain instructions expected by portions of Apple's software.
To compensate, the project uses software routines that reproduce the behavior of those missing instructions.
This can make the system operate correctly under certain circumstances, but it also introduces additional processing overhead.
The achievement required changes to the boot process, processor initialization, interrupt handling and memory management.
These are low-level operating-system functions that ordinary Android applications never need to modify.
In practical terms, the developer had to persuade Apple's operating-system kernel to start on a processor architecture that was never part of Apple's supported iPhone hardware.
The iOS Lock Screen Takes Three Minutes to Appear
The boot process itself is another demonstration of how experimental the project remains.
According to the developer's documentation, the Redmi Note 12 requires approximately three minutes to reach the iOS lock screen.
That is much slower than an ordinary modern iPhone.
However, the delay is understandable given the amount of compatibility work occurring during startup.
The process begins with Xiaomi's existing bootloader.
A specially prepared boot image loads a small compatibility program.
That program performs the necessary processor initialization and transfers control to the modified XNU kernel.
The kernel then starts the systems responsible for storage, memory management and the display.
Finally, the genuine iOS user-space components begin loading.
SpringBoard eventually appears, producing Apple's familiar interface.
The result is an unusual sight: a budget Android smartphone displaying the Apple logo and then an authentic iOS lock screen.
The phone presents itself as an iPhone X despite having completely different internal hardware.
Reports and demonstrations published on October 19 suggest the developer has also made progress with touchscreen input.
However, the project's October 18 technical documentation still describes the touch driver as requiring confirmation on the actual device.
The difference reflects how quickly experimental development is progressing.
Some demonstrations may show features that are not yet considered reliable or complete.
For now, successful booting is the established milestone.
The device's ability to navigate through iOS remains far less mature than that of a normal smartphone.
What Works, What Doesn't, and Why It Matters
A clearer picture emerges when the supported features are separated from the missing ones.
Currently demonstrated capabilities include:
* Starting the modified XNU kernel.
* Loading genuine iOS 16.7.16 system components.
* Accessing the storage system through a custom driver.
* Initializing the four compatible CPU cores.
* Displaying the Apple startup logo.
* Reaching the iOS lock screen.
* Presenting the device as an iPhone X.
* Performing basic software-based graphics rendering.
* Initializing certain background iOS services.
However, major functionality remains unavailable or incomplete.
Touchscreen and physical buttons:
The developer has created touchscreen support and is continuing validation. Reliable hardware-button operation is not yet fully established in the published documentation.
Graphics acceleration:
The Adreno 610 GPU is not yet supported by the iOS port. Visual elements are rendered using the CPU.
Cellular service:
The phone cannot make ordinary calls or use mobile data through the experimental environment.
Wi-Fi and Bluetooth:
Neither wireless connection system is functional.
Camera:
The operating system cannot use the phone's camera hardware.
Audio:
Speakers and other audio functions remain unsupported.
Location and sensors:
GPS and various motion-related sensors do not work.
System clock:
The real-time clock is not properly integrated, causing the displayed date to reset during startup.
Security:
Many mechanisms that normally protect iOS have been disabled or replaced with temporary implementations.
Apple services:
The project does not provide a normal working App Store, Apple ID environment or complete iCloud experience.
The result is therefore not suitable for ordinary activities such as browsing the internet, making calls, listening to music or using banking applications.
It is possible to display recognizable iOS components.
It is not yet possible to use the phone as a conventional iPhone.
Without GPU Drivers, iOS Has to Draw Everything Using the CPU
Graphics performance is one of the project's biggest limitations.
The Redmi Note 12 uses Qualcomm's Adreno 610 GPU.
Under Android, this graphics processor accelerates interface animations, games, video rendering and other visual tasks.
However, Apple's graphics system does not contain the necessary drivers to communicate directly with the Adreno hardware.
The developer has therefore implemented a software-rendering method.
Instead of relying on the GPU, the CPU calculates the visual output and transfers the resulting frames to the display.
This is enough to show the operating system's interface, but it is considerably less efficient than ordinary hardware-accelerated rendering.
Complex animations may become slow or inconsistent.
The method also uses processing resources that would normally be available for other tasks.
A fully functional graphics driver would be a major improvement.
However, writing one is not a simple matter of copying an Android driver into iOS.
The two operating systems use different driver models, graphics frameworks and system interfaces.
A driver designed for Android cannot automatically communicate with Apple's graphics infrastructure.
It would require substantial adaptation.
The developer hopes to introduce Adreno 610 acceleration in a future version.
Until that happens, smooth animations, demanding applications and practical gaming remain unrealistic expectations.
Even with GPU support, numerous other hardware and system components would still need attention before the phone could become useful.
The Project Builds on an Earlier iOS Port for the Redmi Note 10 Pro
The Redmi Note 12 experiment did not begin from scratch.
It builds on another community project called ios-sweet.
Developed by dipa-studio, ios-sweet adapts Apple's XNU kernel and iOS 16 user-space components to the Xiaomi Redmi Note 10 Pro.
That device uses Qualcomm's Snapdragon 732G platform.
The earlier project has already reached a more advanced stage than the Redmi Note 12 port.
According to its documentation, the Redmi Note 10 Pro can reach the iOS home screen and open certain built-in applications.
The touchscreen and physical buttons work.
Users can interact with portions of Settings, Control Center and the notification interface.
However, it also lacks major hardware support, including wireless communication, audio, cameras and GPU acceleration.
The earlier developers had to create custom solutions for several essential functions.
Those include storage access, basic display output and the translation of touchscreen activity into events the iOS interface can understand.
Makr adapted that work for the Redmi Note 12's different chipset and hardware configuration.
The two Xiaomi models may appear similar from a consumer perspective, but their internal components are not identical.
Different processors, touch controllers, memory arrangements and bootloader behavior can require substantial changes.
The Redmi Note 12 project therefore represents a continuation of existing technical research rather than an entirely unrelated breakthrough.
That distinction is important because community-developed projects frequently advance through collaboration.
One developer solves a difficult problem.
Another adapts the solution to different hardware.
Over time, the combined work can make previously impractical experiments possible.
The Same Developer Has Also Been Running Windows on the Redmi
The creator of ios-topaz has another project that helps explain how the iOS port became possible.
MakrSas has also been developing a Windows-on-ARM environment for the Redmi Note 12 4G.
That project is known as topaz-woa.
Unlike the iOS experiment, the Windows project already includes functioning support for several important hardware components.
Its published documentation describes working graphics acceleration through the Adreno 610 GPU, touchscreen input, physical buttons and Wi-Fi connectivity.
Speaker output and battery-related functions have also received development work.
The Windows project remains experimental, with additional limitations involving cameras, Bluetooth and other features.
Nevertheless, it provides valuable information about how the Redmi's components operate.
The developer hopes to reuse parts of that research while improving the iOS port.
For example, understanding how the touchscreen controller communicates with the processor can help when implementing an equivalent driver for XNU.
The same principle applies to power-management components, wireless hardware and graphics initialization.
However, the Windows drivers themselves cannot simply be transferred unchanged.
Windows and iOS use different kernel interfaces and driver architectures.
The existing code and hardware knowledge can accelerate development, but compatible iOS components still have to be written and tested.
The fact that the same inexpensive smartphone has become a test platform for Android, Windows and iOS is especially remarkable.
It demonstrates how versatile modern mobile hardware can be when developers are willing to work around the restrictions of conventional software platforms.
Can Anyone Install iOS 16 on Their Own Redmi Note 12?
The project is publicly available, but that does not mean it is suitable for ordinary smartphone owners.
The developer has published source code and documentation explaining how the experimental environment is built.
A compatible Redmi Note 12 4G is required.
The phone must also have an unlocked bootloader.
The documented process involves specialized development tools, a Linux computer and an iOS firmware image for the iPhone X.
The operating-system kernel must be built with the required modifications.
The iOS system files must then be prepared in a storage image compatible with the modified environment.
The experiment uses the phone's user-data partition to store the iOS installation.
That creates one particularly important risk.
Installing the project erases the existing Android user-data partition.
Photographs, downloaded files, application data and other locally stored information can be lost if they have not been backed up.
Although the modified kernel is started from memory rather than permanently replacing the device's boot partitions, the installation is not harmless or completely reversible without preparation.
The existing Android system files may remain on the phone, but its user data does not.
The project also does not provide a normal secure computing environment.
Several essential security protections are disabled to allow Apple's software to operate without the expected hardware.
This makes the experimental system inappropriate for passwords, banking information, private conversations or other sensitive personal data.
It is best suited to a spare development device.
Anyone whose Redmi Note 12 is their primary smartphone should avoid treating the project as a practical replacement for Android.
Even successful installation would leave the phone without the basic functions expected from a modern mobile device.
Why Apple's Open-Source Kernel Does Not Mean iOS Is Open Source
Another important distinction concerns Apple's software licensing and development model.
Apple releases source code for portions of its operating systems, including the XNU kernel.
XNU provides foundational services involving processors, memory, processes and other low-level functions.
Its source availability allows developers to study the kernel and adapt certain components to different environments, subject to the applicable licenses.
However, iOS as a complete operating system is not open source.
Many of the frameworks, applications and services that make an iPhone recognizable remain proprietary Apple software.
That includes important parts of the graphical interface and the broader Apple ecosystem.
The ios-topaz project therefore combines modified open-source kernel components with genuine proprietary iOS software obtained from iPhone firmware.
The developer does not distribute a complete ready-to-install copy of Apple's operating system through the source repository.
Instead, the documentation describes preparing the required system files from an Apple firmware package.
There are also licensing questions surrounding the use of iOS on non-Apple hardware.
Apple does not officially authorize installing its mobile operating system on Xiaomi smartphones.
The existence of public source code for XNU does not grant unrestricted rights to redistribute or use every proprietary component of iOS.
These considerations are another reason the project should be viewed as experimental research rather than a legitimate commercial alternative to buying an iPhone.
It demonstrates technical possibilities.
It does not establish official compatibility, licensing approval or a supported path for consumers.
Could This Eventually Lead to Fully Functional iOS on Android Phones?
The obvious question is whether continued development could eventually make an Android smartphone run iOS well enough for everyday use.
Theoretically, some of the current problems may be solvable.
Developers could write additional drivers for the touchscreen, buttons, wireless components and audio hardware.
Graphics acceleration could be improved.
The system clock could be integrated properly.
Support for additional processor cores might eventually be possible through more extensive kernel modifications.
However, other obstacles are considerably more difficult.
Modern Apple devices use dedicated security technologies that are deeply integrated with the operating system.
Functions involving secure storage, biometric authentication, activation and certain protected services depend on hardware and software arrangements that ordinary Android phones do not reproduce.
The Redmi Note 12 has no Apple Secure Enclave.
It also lacks the exact hardware environment expected by the imported iOS firmware.
Replacing those components with experimental software may be sufficient to start certain services, but it does not reproduce their security properties.
Application compatibility would present additional challenges.
Many applications depend on Apple frameworks, graphics acceleration, device services and security mechanisms functioning correctly.
An application that launches successfully might still fail when it attempts to access the camera, network or protected storage.
There are also performance limitations.
The Redmi Note 12 is a relatively modest smartphone, and running an extensively modified operating system may introduce additional processing overhead.
Consequently, the path from displaying a lock screen to providing a reliable daily-use smartphone is enormous.
There is no confirmed schedule for achieving complete hardware support.
The developer's roadmap focuses on incremental improvements rather than promising a finished iPhone replacement.
That is a sensible approach.
In experimental operating-system development, getting a new component working reliably is often a meaningful accomplishment in its own right.
The Real Achievement Is Making Two Closed Ecosystems Meet
The most interesting part of the Redmi Note 12 experiment is not simply that an Android phone displays an Apple logo.
It is the amount of engineering required to make genuine iOS components start on hardware that Apple never intended to support.
The developer has had to address differences in processor behavior, memory management, boot procedures, storage access and display output.
The project also shows the importance of open-source software and community collaboration.
Without access to portions of Apple's XNU source code, the work would be substantially more difficult.
Without the earlier ios-sweet project, the Redmi Note 12 port would have required more foundational engineering.
And without the developer's experience running Windows on the same phone, identifying certain hardware interfaces might have taken considerably longer.
The result is not a practical smartphone.
It cannot currently replace Android, and it does not offer the complete functionality or security of a genuine iPhone.
But that does not make the experiment insignificant.
Reaching the iOS lock screen means that enough of Apple's system software is running to demonstrate that the fundamental concept can work.
Future improvements may bring better touchscreen interaction, hardware graphics acceleration and selected additional functions.
Even if a fully usable port never emerges, the project will have contributed valuable research into mobile hardware and operating-system compatibility.
It also challenges a familiar assumption that mobile operating systems are inseparable from the devices for which their manufacturers originally designed them.
The reality is more complicated.
Software restrictions, hardware dependencies and security architecture make cross-platform ports extraordinarily difficult, but determined developers can sometimes overcome enough of those obstacles to produce surprising results.
For now, the Redmi Note 12 running iOS 16 remains an impressive technological curiosity.
It has an Apple operating system, a Xiaomi body, a Qualcomm processor and a very long list of features that still do not work.
But the next time someone says that putting real iOS on an Android phone is completely impossible, this developer has a three-minute boot sequence and an iPhone X lock screen that suggest otherwise.
Video:
View the attachments for this post at:
http://www.jlaforums.com/viewtopic.php?p=712588918#712588918
--
Via JLA Forums web gateway for comp.mobile.android
--- Synchronet 3.22a-Linux NewsLink 1.2