The world of mobile app development has evolved drastically in recent years, and the number of tools and technologies available to developers has grown exponentially. Mobile applications can generally be classified into two categories - hybrid and native, there is already a significant amount of literature available on the pros and cons of each option, so, in this article, we will take a closer look at the process of developing native iOS mobile applications, with a particular emphasis on the design phase. Developing native applications requires a significant investment of time and resources, and the design process plays a critical role in ensuring the success of the final product. The most popular tool used by iOS developers is the storyboard designer, which is an intuitive and efficient way to create application interfaces without writing any code. 

The Storyboard tool and its navigation bar provides a drag-and-drop interface for designing application screens, and users can add various UI elements such as buttons, labels, images, and text fields. The tool also provides a canvas to view and arrange these elements and allows designers to set constraints to ensure that the layout looks consistent across different screen sizes. For simple applications, the storyboard designer can be a powerful tool for creating a complete application interface without writing any code. This can be a huge time saver, especially for designers who are not as comfortable with coding or who prefer to focus on other aspects of the project. By using the tool, designers can quickly create interfaces and try multiple design options to find the best one for the application. 

However, as the complexity of the application grows, the Swift Storyboard tool may not be enough to meet all design requirements. For example, if an application requires special effects, or a more advanced look, then designers may need to add additional code or use external libraries to achieve their desired effect. 

Another consideration when using the storyboards in iOS is that it may not be the best option for collaborative design. While designers can create application interfaces using the tool, developers may need to make changes or adjustments to the design in order to accommodate technical requirements. In these cases, designers may need to work closely with developers to ensure that the final product meets both design and technical specifications. 

Another available strategy is to use swiftUI still it is important to mention some aspects to consider: 

Compatibility Issues 

1. One of the primary reasons for the slow adoption of SwiftUI is compatibility issues. SwiftUI is only available on iOS 13 and above, which means that developers cannot use it to build apps

for older versions of iOS. This presents a challenge for developers who need to support a wide range of devices and operating systems. 

Learning Curve 

SwiftUI has a steep learning curve, especially for developers who are new to iOS app development. Unlike other UI frameworks, SwiftUI requires a different way of thinking about user interfaces. Developers who are used to building user interfaces using UIKit may find the transition to SwiftUI challenging, which can slow down the development process. 

Limited Documentation 

While SwiftUI has been available for a few years now, the documentation and resources available are limited compared to other UI frameworks. Developers may find it difficult to find answers to their questions or to learn how to use specific features. This lack of documentation can lead to frustration and further slow down the development process. 

Limited Third-Party Support 

Another factor that affects the adoption of SwiftUI is the limited third-party support. While SwiftUI is an Apple framework, it is not yet widely supported by third-party tools and libraries. Developers may find it challenging to integrate their existing code and libraries with SwiftUI, which can also slow down development. 

Integration with Existing Codebase 

For many developers, integration with an existing codebase is an essential consideration. SwiftUI's declarative syntax is fundamentally different from UIKit's imperative syntax. This difference can make it difficult to integrate SwiftUI into existing codebases, which can be a significant hurdle for developers. 

Lastly, swiftUI does not completely solve some problems such as having to develop each view individually, also the number of properties and components that this tool provides are still limited. While both storyboard and SwiftUI provide ways for developers to create interesting designs, they may still require complex code to achieve the desired result. This can be time-consuming and may not be feasible for developers with limited resources or tight deadlines. As a result, some developers may choose to migrate to alternative technologies, such as hybrid development (hybrid in any of its forms). 

But there is a way to achieve a complex design while maintaining the native development with all its advantages. This is the MCSS framework, with this technology, you can easily assign classes and IDs to the various components of your mobile applications like in a web page and then create one or more mcss files (like css files) with selectors and rules to edit all the components in the whole

application at the same time even in different views. You can create selectors to point to a particular component or a group of components using classes or even create complex combined selectors. MCSS really allows you to create a complex design very easily or totally replace the appearance of your app in a couple of hours or even in minutes. The best thing is that the learning curve is short if you have basic css knowledge which is very common. 

MCSS guarantees you a nice application look as easy as creating a web page and your app stays native, MCSS is designed to work over Xcode (and Android IDEs)