Architecture, features, and templates without sacrificing quality.

SwiftUI makes it easier to build beautiful iOS apps. That part is true.

Shipping a production-ready app is still hard.

The difference between a prototype and a reliable product is rarely UI polish alone. It is architecture discipline, predictable state handling, resilient networking, sane persistence choices, and release workflows that do not break every sprint.

This guide is for developers, agencies, and technical founders who want to ship faster without creating fragile codebases.

You will learn:

• When templates accelerate delivery and when they hurt
• How to structure a scalable SwiftUI app with MVVM
• How to plan core features that most apps need
• How to approach chat and WebRTC with production constraints
• How to choose templates responsibly and customize them deeply

If you want a baseline catalog first, browse iOS templates and then come back to this guide to pick the right starting point.

When You Should Use a SwiftUI Template (And When You Shouldn’t)​

Templates are not a substitute for engineering judgment. They are an acceleration layer.

Use a template when​

• You are validating an MVP and time-to-feedback matters
• You are shipping repeated client apps with similar building blocks
• You already know your scope and want to skip repetitive setup
• You want working references for navigation, auth flow, and UI states

Avoid templates when​

• Your primary goal is learning SwiftUI fundamentals from first principles
• You are intentionally experimenting with architecture patterns
• Your app depends on highly specialized native stacks from day one

A good template removes commodity work. It should not lock your core product decisions.

If you want a lightweight baseline with room for customization, start from SwiftUI Starter.

The Architecture That Scales: MVVM in SwiftUI​

MVVM remains a practical default in SwiftUI because it maps well to declarative views and testable logic boundaries.

Benefits in production:

• Views stay focused on rendering and interaction
• ViewModels become the state and orchestration layer
• Services isolate networking, persistence, and platform integrations

The primary goal is not pattern purity. It is reducing coupling so feature growth stays manageable.

A practical folder structure for real apps​

App/
  Features/
    Auth/
    Chat/
    Profile/
    Payments/
  Core/
    Networking/
    Persistence/
    DesignSystem/
    Analytics/
  Shared/
    Components/
    Utilities/

Architecture rules that prevent scale pain​

• Keep feature modules self-contained
• Keep cross-cutting concerns in Core
• Keep shared UI primitives in Shared
• Keep business rules out of View files
• Keep network and persistence behind service boundaries

Related references:

• MVVM fundamentals in Swift
• MVVM + Combine in SwiftUI

SwiftUI state that matters in production​

A minimal, consistent state model beats over-engineering:

• @State for local, ephemeral view state
• @StateObject when the view owns lifecycle
• @ObservedObject when state is injected

The anti-pattern to avoid is burying side effects inside UI layers. Keep async work in services and make state transitions explicit.

Core Features Most iOS Apps Need (Plan These Early)​

Most teams delay these decisions until late, then pay for it during stabilization.

Authentication​

Most production apps need:

• Email/password or passwordless flow
• Sign in with Apple (often mandatory for app categories)
• Input validation and edge-state handling
• Recovery and account state transitions

Useful references:

• SwiftUI login screen patterns
• Free iPhone login screen template

Data persistence​

Use the least complex persistence layer that satisfies your product constraints:

• UserDefaults for small preference flags
• File storage for lightweight local assets
• Core Data / SQLite for structured or offline-heavy workloads

Guide:

• Data persistence in iOS with Swift

Push notifications​

Push strategy affects retention and user trust:

• Ask permissions contextually, not on first launch blindly
• Separate marketing pushes from transactional notifications
• Support deep links to the exact destination screen

Guide:

• Firebase push notifications in Swift 5

Web content in native apps​

WebView can reduce delivery time for support and legal flows:

• Terms and privacy content
• CMS-driven help pages
• Embedded operational content

Guide:

• WebView in SwiftUI

Payments​

Payment logic is usually underestimated during MVP planning:

• One-time vs subscription flow design
• Entitlement verification strategy
• Failure and refund states

Template reference:

• iOS Stripe Checkout Swift template

Blueprint: Building a Real-Time Chat App in SwiftUI​

Chat is one of the best stress-tests of product architecture. It touches identity, synchronization, persistence, notifications, and high-frequency UI updates.

A production-ready chat baseline should include:

• Authentication + profiles
• Conversation list + message list
• Delivery states and retry behavior
• Pagination for long threads
• Offline read behavior
• Push notifications for message events
• Safety hooks (block/report)

Reference materials:

• SwiftUI chat concepts
• Real-time iOS chat app Firebase tutorial
• Swift Chat App Template
• Swift iOS Chat template (Firebase realtime)

Video Calls and WebRTC in iOS: What You Need to Ship It​

WebRTC can create strong product differentiation, but it introduces complexity in networking and device behavior.

Core requirements:

• Signaling layer for call negotiation
• STUN/TURN for network traversal reliability
• Camera and microphone permission handling
• Audio session management and route switching
• Reconnect behavior and degraded-network fallbacks

Helpful resources and templates:

• WebRTC in Swift
• Video Conference Bundle
• Video and Audio Calling App template
• Swift Video Chat App template

Template Playbooks for High-Demand App Types​

These are practical starting points, not final product blueprints.

Social apps​

Core features:

• Feed rendering and ranking
• Media upload and profile flows
• Engagement actions and moderation controls

Common pitfalls:

• Scroll performance under media load
• Moderation and abuse tooling gaps
• Inconsistent UX states for loading/errors

Starting templates:

• Swift Instagram Clone
• Facebook Clone App

Dating apps​

Core features:

• Profiles and matching logic
• Messaging and notification loop
• Safety controls (report/block)
• Optional premium video call paths

Common pitfalls:

• Verification and fake account handling
• Safety moderation policies
• Poorly designed onboarding causing low activation

Starting templates:

• iOS Dating App Template

Ecommerce apps​

Core features:

• Catalog, product details, cart, checkout
• Order lifecycle and support touchpoints
• Payment and receipt handling

Common pitfalls:

• Pricing consistency and discount logic
• Checkout error handling under poor networks
• Inventory-state drift across app sessions

Starting templates:

• Native Ecommerce App Swift
• Ecommerce iPhone App Template

Dashboard and admin-style apps​

Core features:

• Summaries, charts, filterable lists
• Role-aware navigation and data visibility
• Reliable data loading and caching strategy

Common pitfalls:

• Overdense UI with weak hierarchy
• Inconsistent chart semantics and state handling
• Role logic hard-coded in view layer

Starting points:

• Swift Dashboard App Template

Real estate, listings, and store locator apps​

Core features:

• Listing cards and map context
• Filter flows and favorites
• Lead capture and contact workflows

Common pitfalls:

• Slow map rendering under dense result sets
• Weak caching and stale search data
• Filter UX complexity overwhelming users

Starting templates:

• Real Estate iPhone App Template
• Universal Store Locator iOS App Template

How to Choose the Right Template (Decision Framework)​

A good template reduces risk. A bad template moves risk later into expensive refactors.

Ask before you commit:

• Is it SwiftUI-first or UIKit-first?
• Is architecture explicit and maintainable?
• Is backend replacement feasible (Firebase to custom API)?
• Are critical flows complete (auth, navigation, error/loading states)?
• Can features be extended without touching core internals?

Shipping Faster at Scale (Without Lock-In)​

If you build multiple apps, velocity compounds only when architecture and operations are standardized.

Scalable strategy:

1. Start from a stable template baseline.
2. Extract reusable modules (auth, payments, chat, shared UI).
3. Standardize release and QA playbooks.
4. Apply the same architecture boundaries across projects.

For multi-app teams and agencies:

• iOS Mega Bundle

Treat bundle access as an operational strategy, not only a pricing choice.

FAQ​

Production-Ready SwiftUI Checklist​

Final Takeaway​

Templates do not replace engineering quality. They let you spend engineering effort where it matters most.

Pick the right baseline, preserve architecture boundaries, and customize intentionally. That is how you ship faster while keeping your SwiftUI app stable under real usage.

Pick a proven Swift template and focus on your unique value instead of boilerplate.

If you are building an iOS MVP, the fastest path is starting from a production-ready template. Below are 9 high-demand app ideas and the matching Swift templates to launch quickly.

1. Social or community app​

Build profiles, feeds, and messaging with a clean iOS UX.

Template pick: Swift Instagram Clone. Includes feed, profiles, and social interactions.

2. Dating and matching​

Niche dating apps keep growing thanks to stronger community fit.

Template pick: Swift Dating App Template. Profiles, matching flows, and chat UI included.

3. Real estate or listings​

High-intent users value fast filters, maps, and favorites.

Template pick: Swift Real Estate App Template. Listing cards, filters, and inquiries built in.

4. Ecommerce and subscriptions​

A smooth checkout flow drives strong conversion on iOS.

Template pick: Swift Ecommerce App Template. Catalog, cart, and checkout included.

5. Food and local ordering​

Delivery and takeout keep repeat usage high.

Template pick: Swift Restaurant App Template. Menu browsing and order flow ready.

6. Finance and crypto​

Budgeting and trading apps remain top iOS categories.

Template pick: Swift Crypto App Template. Portfolio views, prices, and charts.

7. Video chat and telehealth​

Reliable calling unlocks tutoring, coaching, and meetings.

Template pick: Swift Video and Audio Calling App. Call screens and real-time communication UX.

8. Store locator and local services​

Map-first discovery works for many verticals.

Template pick: Swift Store Locator App. Map views, filters, and location detail pages.

9. Starter kit for fast MVPs​

If you want to prototype quickly, start with a Firebase-ready base.

Template pick: Swift Boilerplate with Firebase. Auth, onboarding, and a solid Firebase base.

Ship faster​

• Launch with one core loop.
• Add analytics and push notifications early.
• Iterate weekly based on retention data.
• Keep the UI simple and fast.

How to choose the right template​

• Pick the template that matches your core loop.
• Avoid over-customizing before validation.
• Focus on onboarding and one key action.

UX polish that improves conversion​

• Keep first-time user flow under one minute.
• Use clear empty states and progress hints.
• Ask for permissions only when needed.

App Store readiness​

• Prepare screenshots and a short preview video.
• Use a concise description and strong keywords.
• Test on multiple iPhone sizes before launch.

Start from a proven Swift template and focus on what makes your app unique.

iOS users expect fast performance, clean UX, and helpful features. The categories below consistently show strong demand and clear monetization paths. Each one includes a matching Swift template to accelerate your launch.

1. Smart dashboards and insights​

Users want answers, not charts. Summaries and insights drive engagement.

Template pick: Swift Dashboard App Template. Great for KPI cards, charts, and summary screens.

2. Finance and investing​

Budgeting, crypto, and trading remain top performers on iOS.

Template picks: Swift Finance App and Swift Stock Trading App. Both include portfolio views, charts, and insights.

3. Video and audio communication​

Real-time calling is now a baseline feature for many verticals.

Template pick: Swift Video and Audio Calling App. Ships with call screens and real-time communication UX.

4. Food delivery and local commerce​

Ordering and delivery flows drive repeat usage and strong reviews.

Template pick: Swift Food Delivery App. Menu browsing, cart, and delivery status are built in.

5. Fitness and wellness​

Habit loops and progress tracking create consistent engagement.

Template pick: Swift Fitness App. Workout flows, progress tracking, and goal screens included.

6. Marketplaces and discovery​

Maps plus listings are powerful for local services and vertical marketplaces.

Template pick: Swift Store Locator App. Map views, filters, and location details ready.

7. Social and dating​

Niche communities and dating apps keep growing thanks to strong retention loops.

Template pick: Swift Dating App Template. Profiles, matching flows, and chat UI included.

8. Ecommerce and subscriptions​

A fast checkout and smooth onboarding increases iOS conversion.

Template pick: Swift Ecommerce App. Catalog, cart, and checkout screens out of the box.

Launch checklist​

• Build one core loop and remove everything else.
• Add push notifications and lifecycle messaging early.
• Start from a production-ready Swift template.
• Measure retention and conversion from day one.

Monetization options​

• Subscriptions for recurring value and content.
• Transaction fees for marketplaces and bookings.
• Premium upgrades for power users.
• B2B licensing for dashboard-style apps.

Retention loops that work on iOS​

• Save and return lists (favorites, watchlists).
• Weekly progress summaries.
• Limited-time offers or streaks.
• Personalized recommendations.

App Store success checklist​

• Clear screenshots that show the core loop.
• A short description with your main keyword.
• Fast onboarding with minimal friction.
• A privacy policy and data clarity from day one.

Want to move faster? Explore the full iOS app template catalog and ship in weeks, not months.

As AI tools like ChatGPT and GitHub Copilot become increasingly integrated into development workflows, a new phenomenon called "vibe coding" has emerged. This article explores the impact of AI-assisted development on Swift and iOS programming, weighing both the revolutionary possibilities and concerning limitations. Whether you're a seasoned developer or just starting your iOS journey, understanding when and how to leverage AI tools effectively could be the difference between enhanced productivity and dangerous dependency.

What is "Vibe Coding"?​

In the rapidly evolving landscape of software development, a new term has emerged: "vibe coding." This refers to the practice of using AI tools like ChatGPT, GitHub Copilot, or Claude to generate large portions of code with minimal human oversight. The developer essentially describes what they want, and the AI "vibes" with that description to produce code that (hopefully) works as intended.

For Swift and iOS development, this approach has gained significant traction, especially among newcomers to the ecosystem. But is it a revolutionary advancement or a concerning trend? Let's dive deeper.

The Rise of AI-Assisted Swift Development​

The introduction of large language models (LLMs) has transformed how many developers approach coding. In the Swift community, these tools offer:

• Quick scaffolding of UIKit or SwiftUI interfaces
• Boilerplate reduction for common iOS patterns
• Rapid prototyping of app features
• On-the-fly documentation that explains Apple frameworks

Many iOS developers report completing tasks in a fraction of the time it would take to write code manually. For those new to Swift or iOS development, AI tools can flatten the learning curve significantly by generating working examples that can be studied and modified.

The Limitations in the Apple Ecosystem​

However, the Swift and iOS ecosystem presents unique challenges for AI-powered coding:

1. Rapid Framework Evolution​

Apple's frameworks evolve quickly with annual updates to iOS, macOS, and Swift itself. As several developers in online discussions have pointed out, LLMs often lag behind these changes:

"Poor vibe-coders; xOS26 and Swift 6.2 is gonna give them one hell of a time."

LLMs can only generate code based on what they've been trained on, which means they may not be familiar with the latest Swift syntax or iOS APIs until they've been widely adopted and documented online.

2. Apple's Unique Design Patterns​

iOS development involves platform-specific patterns and best practices that don't always translate well to generic AI prompts. From respecting the app lifecycle to properly implementing delegate patterns or managing memory in performance-critical code, these nuances often require human expertise.

3. Performance Considerations​

Mobile apps have unique performance constraints that generative AI might not prioritize:

"Several times it's written code for me in C++ which was insanely inefficient algorithmically, so just re-wrote it myself. I only knew that because of my previous experience."

For iOS apps, inefficient code can drain battery life, increase load times, or create laggy user experiences—issues that might not be apparent until the app is deployed to real devices.

The Hidden Costs of Vibe Coding​

Time Efficiency Illusion​

Many experienced Swift developers report that while AI tools appear to save time initially, the reality can be quite different:

"I spend more time guiding it, correcting it, etc than it would take me to write it myself from scratch."

What looks like a 10-minute quick solution often turns into an hour of debugging subtle issues in the generated code, especially for complex Swift features like concurrency, generics, or protocol extensions.

Skill Atrophy​

Perhaps more concerning is the potential impact on developer growth:

"I also noticed how dumber I became fully relying on using LLMs. At some point I started to forget function names I used everyday."

For iOS developers, intimate knowledge of Apple's frameworks is often what separates good from great engineers. Relying too heavily on AI generation can prevent the formation of crucial mental models about how these frameworks work together.

Code Quality and Maintenance​

Generated code often lacks the thoughtfulness and organization that comes from human design:

"The bugs it introduces are frankly unacceptable. It's so untrustworthy that I have stopped using it to generate new code."

In the context of iOS development, where app review rejections can delay launches and updates, these unexpected bugs can have significant business impacts.

A Balanced Approach for iOS Developers​

Rather than taking an all-or-nothing stance on AI tools, many Swift developers are finding a middle ground:

1. Use AI as Enhanced Autocomplete​

Many developers now prefer using tools like GitHub Copilot for line-by-line suggestions rather than generating entire components or classes:

"At the moment I still do use it as unobtrusive autocomplete, but I try to step away from making it generating me whole chunks of app."

This approach maintains developer agency while still boosting productivity.

2. AI-Powered Learning​

For those new to Swift or iOS development, AI tools can be invaluable educational resources. Ask for explanations of complex Swift concepts, have the AI break down Apple's documentation into more digestible chunks, or generate multiple alternative implementations to study different approaches.

3. Delegate Appropriate Tasks​

Reserve AI generation for truly boilerplate code like model definitions, basic networking layers, or standard UI components. Keep the core business logic, performance-critical paths, and architectural decisions in human hands.

4. Rigorous Review and Testing​

When using AI-generated Swift code, implement robust testing practices. Unit tests, UI tests, and performance profiling become even more crucial to catch the subtle issues that might slip through.

The Future of Swift Development​

As we look ahead, it's clear that AI tools will remain part of the iOS development landscape. Apple itself is investing in AI technologies, and future development environments will likely incorporate more AI-assisted features.

However, successful Swift developers will be those who use these tools thoughtfully, understanding both their capabilities and limitations. The most valuable iOS developers won't be those who can prompt an AI most effectively, but those who can:

1. Architect apps that align with Apple's design philosophies
2. Optimize for the unique constraints of mobile devices
3. Navigate Apple's evolving frameworks and technologies
4. Exercise good judgment about when to use AI assistance and when to rely on human expertise

Conclusion​

Vibe coding in Swift and iOS development represents both opportunity and challenge. While AI tools can accelerate certain aspects of development, they're not a replacement for deep platform knowledge and engineering judgment.

As one senior developer aptly put it:

"It's not that I hate the idea of AI, it's just not [always] good. Period."

The most successful iOS developers will be those who harness AI as one tool in a comprehensive toolkit—knowing when to use it, when to question it, and when to set it aside in favor of human creativity and expertise.

What's your experience with AI-assisted Swift coding? Have you found it helpful or harmful to your development process? Share your thoughts in the comments below!

About the author: This article was crafted for iOS App Templates, your premier source for Swift app templates, iOS tutorials, and insights into mobile development best practices.

Looking to start a new mobile app? Launching a mobile app startup has never been easier and hotter. If you are a developer or an entrepreneur looking to launch the next big thing, we've curated a list of the best mobile app ideas to create in 2025. Use it for inspiration and insights into the current mobile market trends. Smartphones have exploded in popularity within the last decade, and they quickly replaced the old desktops for the average consumer. Even laptops are now outdated. Smartphones are our inseparable companions, bringing more convenience and fun into our lives. In addition to concrete mobile app ideas, we also tried to provide some insights on how to generate more app ideas, from our own app generation framework, that gravitates around starting with a niche.

In order to come up with all these hot mobile app ideas, we need to look at the industry trends of the last year. By analyzing all the mobile startups that have raised a lot of capital in private funding rounds, a few themes emerged. The mobile app market is hot, but the competition is also stiff. So you need to start small, in a limited community/market and take it from there. After all, Facebook started in one college, right? Don't try to be Mark Zuckerberg in your first 6 months of launching a startup. Startups are a marathon, not a sprint, so focus on each stage separately. Even if you already have a startup, but you lack a presence in the mobile stores (Apple Store & Google Play Store), you must consider switching your focus to mobile. Or at least add a mobile direction to your company. Even for small traditional businesses, such as restaurants or taxi firms, providing your customers with a hot mobile app will build stronger connections and boost client loyalty. Don't miss out on the revolution that's currently happening. Average users do not use laptops or desktops anymore. Without further ado, let's jump into the best mobile app ideas to launch in 2025, in order to create a successful startup.

1. Dating App Ideas​

If you're looking for a mobile app idea, you are already familiar with hugely successful dating apps such as Tinder or Bumble. They have hundreds of millions of daily active users. They are living proof that the mobile industry revolutionized all the aspects of our lives. And dating is no exception. This incredible transition in dating, from websites (and newspaper ads, remember those?) to mobile apps creates a vast amount of opportunities for entrepreneurs looking to capitalize on mobile startups. Dating applications have taken over the world by storm. The main idea behind these apps is to create a platform that helps people connect to each other seamlessly, find new friends or dates, based on appearance, interests, etc. And these are only a few of the best features of a mobile dating app. To build a successful dating startup, you need to come up with your own original approach. Your app must be unique and genuine, and you should be looking for innovative mobile app ideas. Even if you build the app with similar functionalities, your value proposition should be unique. That's how apps like Grindr, for instance, were able to penetrate the mobile dating market, by targeting a smaller audience, such as the gay community. If you ever decide to pursue our mobile app idea and embark on the journey of building your own mobile dating startup, you should take a look at our mobile dating app template. Our mission is to help entrepreneurs launch their mobile startups faster and at a fraction of the cost. Our dating app template has a large range of features, such as matching, chatting and push notifications with a stunning design and impeccable Swift code.

2. E-commerce App Ideas​

The idea of building an e-commerce application has been around for a long time. Companies such as Amazon or eBay had e-commerce websites since the beginning of the Internet. However, the e-commerce space skyrocketed in the last decade, as mobile device adoption has increased. If you don't believe me, just take a look at Amazon's stock price. Or Shopify's. Shopping on a mobile device is convenient. But shopping in a native mobile app is convenient and FUN. Customers with a native mobile app order 8x more times than customers using a website. The convenience in a mobile e-commerce app comes from frictionless check out experiences (e.g. paying Apple Pay takes on click), as well as an enhanced overall product browsing flows. Using features such as ARKit to preview products will blow the minds of your customers. Let alone beautiful product photo galleries or fast search functionalities. Build amazing e-commerce features, to improve user retention and implicitly, sales. Leveraging push notifications to boost the loyalty of mobile customers, boosts user retention tremendously. This is a key lever in making mobile customers order 8x more times in a native app. Huge competitor advantage. Don't miss out on it. If you are an online e-commerce store owner, you must launch a mobile app. Especially that the app development costs dropped significantly in the last year. Having a mobile app won't be a financial burden in any way. But the prospect of having loyal customers delighted by your WooCommerce or Shopify products makes building a mobile native app a no-brainer. Just look at how many Shopify mobile app builders have popped up on the Shopify App Store in the last year. Your competition might already be pacing you out if you delay this strategy. Even if you don't currently own an e-commerce store, the e-commerce industry is a trillion dollar market. So there's a lot of mobile app ideas you can build to become successful in e-commerce. Given e-commerce mobile apps are a popular mobile app idea in 2025, we implemented a fully functional shopping app template, to help entrepreneurs save thousands of dollars and hours of design, development and testing.

3. Transport / Ridesharing App Ideas​

If you're alive in 2025, I'm sure you've already taken an Uber, Lyft, Taxify, Grab, or Didi. Just in case, these are ride-hailing apps where you can call a cab by specifying your location on a map and tapping one button. Once matched with a driver, you can follow the car on a map, and get more information on the pickup estimate and the driver, such as their rating, photo, and license plate. The ridesharing app idea might feel intimidating at first, especially that the taxi market seems saturated and the bar for creating such a complex mobile app is pretty high. Well, as for the other mobile app ideas, you must start with a niche. Start in your own local market and extend slowly. That's what Lyft and Uber did in San Francisco when they started. Taxify, for instance, is highly successful in Europe even if they started their business many years after Uber entered the European market. The barrier of entry is not as high as it seems. In fact, you can build a ride-hailing app by buying an existing ridesharing app template, which in some cases, costs less than $1000. You can also adjust this idea to different markets. Think outside the taxi space. Where else do people need to call services, based on location? What about handymen, barbers, photographers, teachers, etc? Or target your audience to a smaller market. SaFr, for instance, built a mobile startup just like Uber, but for women only, with women drivers and passengers. Their value prop is safe ridesharing for women, which is a brilliant way to compete with the long-established giants such as Uber or Didi. See where I'm going with this? Ask yourself what is missing in your local market and come up with an "Uber for X" type of mobile app idea.

4. Grocery / Food Delivery App Ideas​

Just like the ridesharing mobile apps jumped in popularity, the food delivery mobile apps have risen tremendously as well. Ordering food from your phone is fun and convenient. You don't need to open a web browser, type in the website name, register/login on a no-name site and then order food, just to find out they are out of your favorite pizza. Food Delivery apps such as UberEats, GrubHub, Doordash, Caviar, and Postmates are eating the world. They allow customers to choose from a wide variety of restaurants, without the hassle of creating accounts on each restaurant's website. They truly revolutionized the food delivery market, by allowing each party to focus on what they do best: restaurants focus on making food and the mobile food delivery apps focus on delivering the food. All this benefits the consumer tremendously. Just like the ridesharing industry, this market also seems oversaturated. But the good news holds true here as well: they are businesses focusing on local markets, so you can have a huge competitive advantage if you know your local market better than they do. You know what food is great, what food is not that good, what are the amazing restaurants, etc. Hell, you might even know the restaurant owners personally. Take advantage of this knowledge and build a food delivery app for your local market that is highly customized and offers your local customers a much greater experience than the generalized delivery apps can do. To generate even more mobile app ideas, you can also ask yourself: what else can I deliver besides food? Instacart, for instance, is a mobile startup focusing on grocery delivery. They are highly successful, even if they started way later than Uber or Grubhub. The things people need to deliver are infinite: furniture, construction materials, cars, bikes, etc. Again, find your niche, be it the local market or the idea itself. A lot of innovative mobile startups get created based on this robust delivery model.

5. Travel Apps​

Traveling is extremely popular nowadays. Everyone loves to travel and in these days, traveling is extremely affordable. Flights are cheap, mobility is high and technology is your travel guide (maps, information, translation, etc). There are great companies capitalizing on the travel industry already. I'm sure you are already familiar with Airbnb, CouchSurfing, Booking, Expedia, etc. Just think outside the box, and come up with an original app idea to build for your startup. Focus on a specific niche, that you are familiar with and are passionate about. Build an Airbnb for camping, or for cars, or for work, etc. There are a ton of mobile app ideas you can generate with this framework here. Just find something sound and do it with passion.

6. Social Networking​

Social networking might sound like the oldest and most non-buzzwordy mobile app ideas ever. But social networks are not going anywhere. You can argue that the market is saturated, due to Facebook and WeChat, but hey, plenty of other mobile apps more recently launched prove you wrong: Instagram, TikTok, SnapChat, etc. A social network is still a hot mobile app idea. Humans are social beings – we love to interact with each other. And we love diversity. Each of the existing successful social apps has its own angle in terms of value proposition:

• Instagram – high-quality visual photos
• TikTok – short-form vertical videos
• Snapchat – disappearing messages
• Twitter – short-form text messages
• Linkedin – social network for professionals/careers
• Whatsapp – encrypted private messaging

You get the idea, right? Come up with your own social networking value proposition and build a successful social network. People have multiple personalities, they have different types of acquaintances (friends, family, teachers, work colleagues, bosses, interests, etc.), so all these represent great opportunities for an entrepreneur looking to tackle the social media space. Or, you can tackle this from a different perspective, and try to be a direct competitor to an existing app. With a twist. For instance, in the light of recent Facebook's privacy scandals, you could build a social network focusing on user privacy and encryption. That would be shooting for the moon, but hey, who knows? Make your own social network fun, useful and addictive, target a niche audience (for the beginning), make sure you have a differentiating value proposition and go get them.

7. Store Directory / Business Locator​

Have you heard about Yelp or Foursquare? These apps allow users to find different small businesses or stores around them. You can find anything, from handymen, photographers, accountants, doctors, to barber shops, restaurants, and shopping malls. What's truly innovative about these startups/companies, is that they have a rating and review system for each of the stores and businesses in the directories, where users can voice their opinions on the experience they had with that entity. So users are using these apps to read reviews about the people and businesses they want to engage with. This mobile app idea is also extremely local. Each city has its own mini-marketplace when it comes to doctors, restaurants, handymen, parks, etc. Which is one of the reason apps like Yelp struggle to extend internationally. But this represents a great opportunity for mobile entrepreneurs. You can launch a better version of Yelp or Foursquare tailored to your local market, be it your own city or country. By building a local ecosystem, you can launch a much better product that Yelp can do, since your mobile app will focus solely on a specific highly customized market. You can even restrict your niche, by going after only one category (doctors, for instance) and excel at it. The mobile app ideas you can generate from this are absolutely endless. Think only about how many categories there are on Yelp or Thumbtack. In implementing this mobile app idea, you need to add at the very list critical features such as map views, location services, reviews & rating system, search, user onboarding, etc. The great news is that developing an app like Yelp is actually pretty easy nowadays, especially if you use one of our store locator app templates.

So between Google and a colorful application, and UI is presented scientifically like this, which one do you prefer? In addition, there are other features that you can add to your application such as a group filter, save a store you love, and leave your comments, etc. All of these features have been implemented in our templates, and with just an amount of money equal to a few cups of cocktails, you'll become a formidable opponent to Google in the future.

8. Cryptocurrency App Ideas​

A very lucrative mobile app idea as of last year is cryptocurrency related. With ICOs and Bitcoin blowing up in popularity at the end of 2022, 2025 is the year when the crypto market becomes more mature and stable. So it's no surprise lots of mobile cryptocurrencies exchanges are popping up at an accelerated pace. Mobile startups such as Coinbase, Binance, Gemini, Robinhood or Coin Stats have capitalized on billions of dollars of crypto-related activity, within the last year alone. The market is still in its incipient stages. So the mobile app ideas in the crypto space are limitless.

If you're looking to start a new app, make sure you analyze the cryptocurrency space. Blockchain and smart contracts are new industries in themselves, so entering it is like entering the Internet business market in the 90s. It's not clear who the winners will be yet, so why not you? Around this app idea, there's a ton of types of mobile apps you can build. From the trivial ones, such as cryptocurrency exchanges apps (for Bitcoin, Ethereum, Litecoin, Ripple, etc. trading) and Bitcoin / Crypto wallets, to more advanced ones, such as digital wallets, Bitcoin payment apps, and platforms, etc. Here are the top mobile app ideas for cryptocurrencies:

• Crypto Payment Platform
• Crypto Trading app / Crypto Exchange
• Multi-currency Wallet
• Statistics Aggregation Point (think Bloomberg terminal for crypto)
• Peer-to-peer cryptocurrency payments (Venmo/Square for crypto)

We've built an app template ourselves, in order to help cryptocurrency entrepreneurs launch Bitcoin/Crypto apps much faster. Check out our Crypto App Template or Cryptocurrency Exchange Template if you're looking to move quickly with your crypto app development.

9. Mobile apps for restaurants, coffee shops, bars and more.​

Small business owners have a huge opportunity ahead. Building a companion app for a small business might prove to be a very profitable idea. A small local business, such as a restaurant, coffee shop, bar, pubs, dentists, hair salons, etc. could benefit from a mobile app, by offering to their loyal clients, convenient features, such as appointments, online orders, mobile payments, special discounts, events, and notifications. Imagine you get to notify your loyal customers that there's a huge discount on beer for tonight's football game at their favorite bar nearby? Sounds like the recipes for success, right? Managing appointments or table reservations for a restaurant, a doctor's office or a hair salon is also a great way to provide your customers with convenient user experience. Millennials, for instance, hate to speak on the phone, but they love to use their mobile phones. You can also add features such as reminders with push notifications, to provide an even better native experience. Nothing a website can do, really. This is one of the best mobile app ideas for small business owners. Keep up with the times, people! You'll be able to boost your sales by bringing in an additional revenue stream. Retain your loyal customers and create a predictable revenue avenue, by expanding your business beyond the four physical walls, that are limiting you so much. The same ideas apply to almost any small business providing services locally. Starbucks has a mobile app. Your local competitor will have one too pretty soon. Don't fall behind. Millennials are coming. We strongly believe in this mobile app idea, which is why we've built this restaurant app template. If you own a restaurant, coffee shop or bar, you can literally submit your working app to the App Store today. As you can see, the cost of developing a mobile app for your small business is really low nowadays, so there are no excuses really.

10. Virtual Reality / Augmented Reality App Ideas​

Virtual reality, augmented reality, artificial intelligence and cryptocurrency are the hottest buzzwords in Silicon Valley. They are hot in the Bay Area for a reason, so pay attention to them, if you're looking for a new startup idea. AR technology has developed rapidly and in the near future, it will become extremely popular. Especially with new frameworks coming from Google and Apple, such as ARKit and MLKit. With this technology, you will have the opportunity to build brand new original experiences for your customers and consumers. For example, Ikea's mobile app allows you to preview the furniture in AR, by placing it in your living room, to see how it fits. All of this, without taking any measurements or even leaving the house. This type of experiences is really useful for furniture stores, repair or design services, artistic apps, e-commerce apps, etc. Even social networks – imagine hanging out with your friends abroad, through VR rooms. There are a ton of mobile app ideas you can generate in the AR / VR space. All of them are fun, but could be a little hard to build. Apple and Google are working hard on lowering the bar of entering these markets for developers and entrepreneurs. Augmented Reality is a new industry in itself, so just as the cryptocurrency space, we don't know the winners yet, so entering this brand new market might be a brilliant idea given its incipient stages. The competition is not that stiff either, so that's an extra opportunity.

11. Music Streaming App Ideas​

Spotify just went IPO this year. They are officially a $15B business. Huge, right? Apple Music is even larger than Spotify. Amazon has launched its own music streaming service. Besos might be up to something, right? Soundcloud is also pretty successful, even though they have a different angle. That's what you need too. A different angle. Try to find a smaller niche, maybe target a specific audience for your artists or listeners and launch a music streaming app to ride the wave of content streaming popularity. Here's a concrete idea: why not create Spotify clone for your country, that is highly customized to your culture? Spotify will never do that. Wink, wink. You get the idea. Well, the mobile app idea in this case.

12. Video Streaming App Ideas​

Two video streaming app behemoths here: Netflix and Youtube. And all of their competitors, of course. Apps such as Hulu, Amazon Prime Video, Disney Plus, IQIYI, etc. are capitalizing massively on the death of TV as we know it. This is the best time to join them. Look at Netflix's stock in the last 2 years, to understand how hot this industry really is. With the great Internet infrastructure, streaming videos nowadays comes at no price to developed areas, so consumers are watching more and more videos on mobile devices. As in any startup idea, you need to come with your own original angle, in order to build an innovative and unique mobile app. Find a video streaming niche and take it from there. The possibilities are endless. Just find the X in "Netflix for X". It can be anything: Netflix for Salespeople, Netflix for developers, Netflix for designers, courses, Netflix for marketing, etc. Find your X.

Conclusion on Mobile App Ideas​

Regardless of your goal, be it improving profits for your current business or changing the world through a new innovative mobile app startup, I hope that this article on mobile app ideas was useful and inspiring. Remember, no ideas are too big, you just need to start small. Mobile is eating the world with software, so pay attention and ride the wave. Don't miss out on the revolution that's happening right in front of you. At iOS App Templates we are trying our best to identify the hottest trends in terms of mobile usage and development so that we can predict what types of apps to build next. Our mission is to help people like you get started on their new mobile journey. That's how this list of the best mobile app ideas came to reality. If you enjoyed going through our insights on the best mobile app ideas, please spread the word by sharing our article on your social media. Cheers!

As you know, there are a lot of design patterns applicable in Swift such as MVC, MVP, and MVVM. Depending on the project’s purpose, we choose which one is most appropriate. At iosapptemplates.com, we use a wide variety of Swift design patterns to build our functional mobile app templates. In this article, we’re going to tackle some of the advantages that come with using MVVM Swift and explain clearly with Swift code snippets.

MVVM stands for Model – View (View here is View Controller (VC)) – View Model (VM). So what does it mean? It means we are introducing a new component called View Model to help with the heavy workload.

Previously, everything including the networking, fetching back the response, handling signals from UI etc, was living inside the View Controller. This made it overloaded. So in MVVM, we will divide the work and delegate responsibility to the view model.

Components Overview and Specific Roles​

So in general, we have:

• View Controller: It only performs things related to UI – Show/get information. Part of the view layer
• View Model: It receives information from VC, handles all this information and sends it back to VC.
• Model: This is only your model, nothing much here. It’s exactly the same model as in MVC. It is used by VM, and updates whenever VM sends new updates

In an actual project, there are two main points you should remember while working with this article:

1. The convenience when separating work like this.
2. Each component in charge of any particular part will be fully independent of each other.

MVVM Swift Example by Building a Login Screen​

In this article, we will have a login function which handles data inside the View Model. For this comparison, I will ignore the autolayout part and interface builder changes, and solely focus on the connection between VC and VM. Now, let’s get started.

Here’s what I got in the starter project. We have all IBOutlets and IBActions – and two important files (VM, VC) of course.

Now we will talk about each file here. As we saw at the beginning of this article, we all know the role of VC is to only display and get information from UI. We will apply these points here:

• Get information from UI: that is the value from the text fields
• Show and respond to the data from VM: after tapping the Login button, we will see a message which indicates whether the user logged in successfully. It depends on the signal from VM.

Alright, the problem is how we can connect the two files to each other. There are two common ways: protocol-delegate and RxSwift. In this part, I will talk about protocol-delegate. This approach has two advantages:

• It’s very clear, we can know the basic information which is delivered between two classes
• Each component in charge of any particular part will be fully independent of each other

1. Sending data from View Controller to View Model​

In this part, we have three steps:

Step 1: Creating a protocol named ViewModelDelegate​

This protocol is part of the view model and it has a function called:

func sendValue(from emailTextField: String?, passwordTextField: String?)

func sendValue(from emailTextField: String?, passwordTextField: String?)

Step 2: Wiring the view model to the view layer​

Next, we will create a viewModel variable inside the view controller and here we will send the value of emailTextField and passwordTextField.

Alright, it looks cool, right? It looks like we wrapped the information in the package and sent it. The next step, we’ll see where to receive and unwrap this package.

Step 3: Handling the actions in the view model​

After getting information from the view controller, we can handle it in the View Model like this:

Run and fill some values in emailTextField and passwordTextField and see what happens.

As you can see, I receive “Email Testing” and “Password Testing” from VC.

2. Sending data from the view model back to the View layer​

Let’s first create another protocol called ViewControllerDelegate, and have the view controller conform to it. This means we don’t care what the view model did, we just need the result of that operation.

This is a great advantage of MVVM. Whoever is in charge of VC will not care what VM did, they just need the result. Likewise, VM does not need to know where or how VC got values from UI, it only cares what it needs to do with those values. So, all the concerns are separated, keeping all the components independent of each other.

For my example, you could see that who’s in charge of coding the view model will care about what it needs to do with emailTextField and passwordTextField, but it doesn’t need to know where these values are coming from. This business belongs to the view layer.

Above is the protocol that I mentioned before, and it has a function named getInformationBack. It means we will get values back from VM through this method.

In ViewModel, let’s add a weak delegate variable

weak var delegate: ViewControllerDelegate?

and send the value which is retrieved from emailTextField and passwordTextField. In this tutorial, I will not handle anything too complicated, just combine the two strings into one, like in the following image:

Alright, here, we wrapped the final output after handling the value (actually we only concatenated them, but in an actual project, you could do more like validating the email, password and tell VC if it’s available). Let’s now see how we can retrieve the data back into the view controller.

In viewDidLoad of VC, we have this line of code: viewModel.delegate = self. Remember that we have a delegate variable in VM, right? This line of code is kind of VC telling VM that it will do the delegation.

And then, we just need to conform the protocol and get the value back from VM.

Build and run the Xcode project again. We will have all that we need now. We can send the data from VC to VM and vice versa.

Conclusion​

Let’s wrap up what we have done. In MVVM, we assigned the tasks related to calculate, handle data etc. to VM. We only allow the view layer to do UI chores and get values from UI and user interaction. In this way, each design component is in charge of only one specifically dedicated concerns and they are completely independent of each other. That’s all. I hope after this article, you will have an overview of MVVM Swift and how to implement it using the protocol-delegate design pattern.

MVVM is a powerful architecture pattern in Swift and it allows programmers to separate concerns of their design components, so getting a grasp of it is highly essential to any great iOS engineer.

Hello developers, especially beginners! As you know, at WWDC 2019, Apple launched a new awesome feature called SwiftUI, which will be a new breakthrough in UI programming, enabling developers to have more time to develop ideas instead of focusing on technical stuff.

Since then, it has become easier for beginners to learn iOS development. After we learning the basics, everyone should try to make an application to apply the knowledge and see the gaps between theory and practice for themselves. However, it's hard to come up with an app idea that is suitable for everyone's level. So this article is for you. In addition to giving iOS app ideas, we will help you get different perspectives on what you can learn from each of them.

1. Expense Tracker​

The idea of ​​this app is to manage your money & finances, allow you to see your spending by category, set up bill payments, keep track of your incomes, and plan for savings.

The required features of the app are:​

• Display and compare total cost by day, month, year.

• Show your invoices during the day.

• Add a new invoice.

• Show categories (including food, water bills, etc).

• Show categories with used invoices (for collecting purpose).

This expense management app works in the following way:​

First, in the Home screen, you will see comparative charts which will help keep track and make comparisons of the current day's expenses. Below the charts, a list will display all invoices you have paid that day.

Next, as you click the Add New button, catalogs will appear. Clicking on each specific catalog will lead to the next screen where you can input the amount of money and give a description for that invoice.

When things are done, the app will automatically return to its home screen. By utilizing the Tabbar navigation, you can create 3 items: Home, Activities, and Setting. Activities screen displays recorded bills in categories (for example, Food: 3 bills, Drink: 4 bills, etc). Clicking on a specific item to see the details.

Setting enables users to edit their information and images.

Here is the link of the above design.

So what can you apply?​

1. Chart View, Table View, Collection View: With the infinite creativity of designers, you can apply knowledge of views to create impressive screens.

2. Tabbar Navigation and View Controller Navigation.

Basically, this app does not need to apply to the server because it is used to track your own costs. However, you can still apply this by using firebase. We will mention this feature in the next parts.

2. Books App​

If with the Expense Tracker application, you don't need to communicate with the server. In this app, let's take that one step further by calling the available APIs like this link, or this. The iOS app idea is to help users read online books. Sounds simple, right? But, it is not as easy as you think.

The required features of the app are:

• Get books from free sources.

• Allow users to read books, even each chapter of any books.

• Bookmark the reading process.

The app will be as follows:

First, the application will retrieve the books from free sources and save them to the local database of the app. Then users select the book they're interested in.

In addition, users can also save the reading process and continue reading afterward. The page flipping effect is the highlight of this app. It makes any type of books more engaging for readers.

Since this app will not have too many features, you can focus more on the UI. Making an attractive and friendly user interface has never been easier to attain.

Check out this link if you want to learn more.

So what can you apply?​

1. Networking, Alamofire, Moya: In this section, you can apply knowledge about communicating networks such as URLSession, Alamofire, or even Moya. Just a small note: If you're completely new, it's really important to learn more about native functions like URLSession to understand deeply the way they work. Using convenient libraries might be reducing your time but when the errors come up, you don't know how to fix it.

2. Local Database: You can use the Realm or Core Data to save data in minutes in order to build mobile apps in a fraction of the time.

3. Collection View: As we said, the page-flipping effect is the place for you to show your creativity to make it truly stand out among other applications.

3. Recipes App​

The idea of Recipes app is to help users have a collection of dishes and recipes they'd like to try. In addition, the app can also add the ingredients into their shopping cart. This is a very simple iOS app idea, extremely suitable for an iOS beginner.

The required features of the app are:​

• Show all dishes and recipes which the app has.

• Show details of each dish, each recipe.

• Add ingredients into the shopping cart enabling users to make quick payments.

• Allow users to perform the payments.

• Optional features: list of saved dishes, tracking your last payments, etc.

The business logic:​

I guess after you read the 3 apps above, you can also imagine how this app works. You can use tabBar navigation controller or side-menu to help users navigate to the screen they wish. In general, we will have four sections:

In the Dashboard screen (or Home, whatever), this will show the top trending recipes. This is where you can unleash your creativity. You can use either a collection view or a table view or combine them as shown below. Of course, users can see the details of each recipe by tapping on that item.

The Detail page will show all the ingredients which users need to make their dishes. In this feature, this part can be updated by integrating to payment allowing them to be able to buy these ingredients. But this task needs a lot of things since you need to link/ co-operate with supermarkets or agents.

Tapping on the Add New button will lead users to the screen where they can add a new favorite recipe. Setting enables users to edit their information and avatars.

This image is referred from this link.

What you can apply:​

1. Firebase/ GCD: In this section, you can create your own server. Use firebase might be a little bit different from the Restful API but the flow you communicate to the server is the same. You send requests and receive responses. The main thing is the way you handle them in the proper threads, avoid blocking UI or some weird behaviors.

2. Local Database: Nothing new but save data in your app.

3. (Optional) Payment: Integrate some payment methods might be a difficult task. But let's challenge yourself. And we are going to introduce it in the next parts.

4. The chat app​

One of the most successful mobile applications is Messenger from Facebook. Creating a chat app is extremely convenient, since it's a popular feature. It is also a great practice opportunity for developers who want to improve their skills. All these make it a perfect iOS app idea to be built by a starting developer.

The features you must have:​

• Login/ Register with popular social platforms such as Facebook, Google, and Twitter.

• Show the list of conversations.

• Real-time text transmission.

• Push notification.

• Optional and advanced features: chatbots, AR/ VR.

The business logic:​

The business logic of this app is not complicated at all. All of the things Messenger can do, your app should also be capable of. You send a message, your friends or groups will receive it. Make sure everything is real-time and when you are out of app, you can receive push notifications whenever the conversations have something new.

The hardest part belongs to the models and their relationships. So please do not think about Chatbots or VR/ AR if you haven't still met the basic requirements.

Please refer to this link for more details.

You can also leverage a chat app clone in order to learn from more experienced developers.

Are there anythings new?:​

1. Firebase & Push notifications: As we said above, let's use Firebase as your own server to save your time and money. Besides that, you can also integrate push notifications with this platform. In theory, it will inform users whenever new messages come up.

2. Real-time text transmission: Does it seem too difficult of a task? Don't worry, since Firebase is a type of real-time database, the only thing you need to do is to observe the signal from the server and update in your app.

5. The social network App​

Yes, you didn't hear wrong. Create your own social network might sound like a joke but it's not. The social network has become a popular application in today's world. The key value of it is to connect people together. We think we don't need to talk too much about the features the app needs. You know better than anyone else. Social networks are one of the most popular iOS app ideas of the decade.

Let's refer to what we have done with our social network template. It got everything that Facebook has.

We highly recommend you to visit this page to dive deeply into all essential features. They have been described in great detail. The backend we use is Firebase including Firebase Auth, Firebase Storage, and Firebase Firestore.

6. To-do list – Tracking task​

After going through these big ideas above, if you feel you're still not good enough to do them. Don't get discouraged. Let's get inspiration back by this one – (To-do list – Tracking task). Although, apps like this are filled on AppStore but it never gets old for new developers. The main purpose is to keep track of what you're doing by days, by weeks, months and years.

The must-have features:​

• Keep track of tasks by days, weeks, months and years.

• Calendars, for sure.

• Local push notification.

The business logic:​

From the key idea of this app, you can develop it into many versions to make differences. It could be tracking by process of the tasks, by group, by categories, by people.

After you have the percent, you can show, display these parameters in a various way. Let's take a look at this following image (or from this), for instance. With the calendar, it will enable users to navigate to any dates to re-check or update tasks.

Which knowledge we can apply here:

• Calendar: Instead of using an existing library, why don't you create your own calendar? Try it and you will find out it's not easy.

• Retain cycle and life cycle of the view controller: Since this kind of app doesn't need to use servers (actually it could), you can focus on the performance of the app. Whether it gets memory leaks, whether it has a bunch of view controllers having not been removed yet after every pushing.

• Local push notification: it could be used for telling users updates.

7. The News App​

Usually, we need this kind of app once we have already contents or a website as WordPress. Then we can integrate with any WordPress website, regardless of its purpose (magazines, blogs, news, etc). All you need to do is specify the address of your WordPress site.

Remarkable features:​

• Automatic WordPress integration

• Real-time updates

[What you can learn]

Again, you can refer to our template to see how we embed a WordPress into an iOS application in action. In theory, regarding building a new reader, you can learn more WKWebView, UIWebView. But recently, UIWebView has been deprecated by Apple since iOS 12, so you should pay attention to this in order to avoid getting rejected when submitting your app into AppStore.

8. The E-commerce App​

Since online shopping on native e-commerce apps has exploded in recent years, it has brought a deep connection between businesses and their customers. The business logic and must-have features are quite similar to the Recipes App. And from now on, there will be a lot of applications having the same features, with similar business flow.

We wrote an article about Best Features Any Ecommerce Mobile App Must Have, it is extremely detailed.

The new skills you can learn here​

• Login with Touch ID (a.k.a fingerprint) or Face ID for frictionless user onboarding process.

• Stripe payment with clouds: It instantly enables users to use their mobile phones for online payments. This task takes a lot of time and effort and it's really worth learning because you have to dive into back-end/ servers part deeper.

9. The Around me App​

One of the popular applications on iPhones is AroundMe application. It allows you to quickly find out what you're searching around you. The app will show you a table view containing categories such as Coffee shops, Gas Stations, Restaurants, etc. Tapping on each item will lead you a list of requested places. Continue to tap on each place will show the detail page with necessary information. Think about this as a Yelp

You can also give users a map to make it more visual. This is also the main feature you need to know when implementing this kind of app. Here is the example on AppStore

Check out our article about MapKit to have a better understanding of this library.

10. The Music/ Radio App​

The last idea is streaming music collection and control music on iOS like Spotify. Yes, you can guess how it looks like. A table view with a bunch of songs and users can select any one of them and enjoy it! This is a fun iOS app idea!

With these free APIs, you can retrieve and save them in your database then show them in your UI. The way and the flow are the same as the ideas above. The only new thing is MediaPlayer library where you can play, next/ previous or stop songs.

Next, you can let users "like" or "share onto the social networks". It is also a new thing you can learn. Let's try it. You could be the next Spotify, like this

Conclusion​

In general, ideas are just ideas. All the above applications need servers, need to be saved to the local database, need to be checked for memory leaks/retain cycle issues, etc. They could use either tabBar navigation or side menu. The important thing is you should know how to compose all of them from communicating to servers to save down to your local database and update UI in runtime without blocking UIs and provide users the best experience.

Besides that, during the development process, you will also learn the way to create and organize models and manage their relationships. The bigger your app is, the more complicated your business logic is. But you must absolutely consider one of these iOS app ideas in order to learn iOS development more quickly.

Where do we go from here?​

There will be a lot of things you need to learn. That's architecture and writing tests. When you're good at Swift, you have to think about how to organize your code to make it easy to test, flexible, maintainable and scalable. Hopefully these iOS app ideas will help you get started with a real world mobile project, and will help you take your programming skills to the next level. And who knows? Maybe one of these iOS app ideas will end up making you millions.

You should always consider starting a project with a fully functional app template, in order to save time and learn from other people, who maybe know more about iOS development. Great artists steal. Check out our awesome iOS app templates.

Thanks for reading to this article. And if you got here, you must love it. Why not share it with your friends?

SwiftUI is the modern way of building user interfaces across all Apple platforms. In this tutorial, we are going to learn how to create a chat app in SwiftUI. There are a lot of interesting concepts that need to be engaged in building a SwiftUI chat app, so there's a lot to learn. Here's how your final SwiftUI app will look like at the end of this tutorial:

Since the day SwiftUI was introduced to the public, a lot of articles and tutorials have been starting to show up. Unfortunately, most of the articles are either too theoretical or too simple. And after a certain threshold of basic knowledge, you inevitably run into big problems in the real iOS world of SwiftUI. So in this SwiftUI article, we are going to conduct a tutorial that is applicable in practice: creating a chat screen UI, displaying messages in a chat application built from scratch. Sound similar, right? Our screen is quite simple but will show you how powerful SwiftUI is. To get a fully functional video chat app by saving years of development and hard work, check out our iOS Video Chat app in SwiftUI.

Getting Started​

This tutorial is geared toward developers who are fairly familiar with SwiftUI, so this time, the requirements might seem quite advanced. Basic components such as VStack, HStack, modifiers such as padding, borders or properties like @Environment, @State, @PublishedSubject will not be reintroduced. You can check out our previous SwiftUI tutorials, if you want to learn about these concepts. In most cases, you'll be able to understand what they do directly from the context, so no need to really learn the theory upfront. Instead, we will talk about how to use, why use and how to combine these concepts. If you are new to SwiftUI, you should read the following articles before continuing.

• Basic components – SwiftUI Introduction
• Properties: SwiftUI State Management

Besides that, you can read all our SwiftUI tutorials to get the basic knowledge on our blog.

Building a SwiftUI Chat App for iOS​

The business logic and the data flow will be very basic, to keep the article as simple as possible. It consists of 3 parts:

• Part 1: Model layer – Business logic code for the models
• Part 2: UI Layer – The chat message cell
• Part 3: Controller layer – Message view controller

1. Implementing the Model Layer​

In this SwiftUI tutorial, we have two models with the most basic properties.

• User with a name, an avatar and a variable to check whether it is the current user. In fact, this User class will need a lot of other parameters. But as said, these 3 properties are enough for this purpose of this SwiftUI tutorial.
• Message stores the content of the message and who owns it.

struct Message {
    var content: String
    var user: User
}

struct User {
    var name: String
    var avatar: String
    var isCurrentUser: Bool = false
}

Additonally, we have instantiated a few models to showcase the behavior of the SwiftUI chat app. You can think about that as mocking data. In general there are many ways to establish relationships between users and messages (even in actual projects) but this is the easiest way to help you understand it.

2. Creating the Views – UI Layer​

Apple encourages us to create as many views as we need, to keep the code easy to read and maintain. Reusable views are greatly recommended. So let's keep this in mind every time we write UI code, and implicitly SwiftUI code. But first, let's paint the whole process before we get started:

• We will have a screen containing messages.
• Corresponding to each message, we will have 2 views representing the content and the avatar, respectively
• If we go into more detail, the content will have a background and font color depending on the type of user, and the remaining modifiers will be the same.

Thus, we will have 3 views – in order from small to bigger:

• ContentMessageView
• MessageView – contains ContentMessageView
• ChatView – contains multiple MessageView objects

2.1. ContentMessageView​

Okay, now, let's create a SwiftUI file in the User Interface and implement the body part. Let's add a few lines of code as follows:

var body: some View {
    Text("Hello world")
        .padding(10)
        .foregroundColor(Color.white)
        .background(Color.blue)
        .cornerRadius(10)
}

So we have created the UI of the content message view. If you are a newbie, you will definitely be lost for words – just like me before. Although there are many issues, it is undeniable the power of SwiftUI – very clean, neat and easy to understand. We still have a few problems to resolve, the background color and the text color of the content view will depend on the type of user. And of course, the Text's content should not be a hardcoded string. Let's make some changes:

struct ContentMessageView: View {
    var contentMessage: String
    var isCurrentUser: Bool

    var body: some View {
        Text(contentMessage)
            .padding(10)
            .foregroundColor(isCurrentUser ? Color.white : Color.black)
            .background(isCurrentUser ? Color.blue : Color(UIColor(red: 240/255, green: 240/255, blue: 240/255, alpha: 1.0)))
            .cornerRadius(10)
    }
}

To test it, run it in the previews section with some mocking values:

struct ContentMessageView_Previews: PreviewProvider {
    static var previews: some View {
        ContentMessageView(contentMessage: "Hi, I am your friend", isCurrentUser: false)
    }
}

2.2. MessageView​

Are you addicted to social networks (specifically Messenger or Whatsapp)? If so, I am sure you will be able to visualize their UI / UX design in your mind. Let's start with the type of user who will receive your message.

• We need an image at the beginning – of course, it is going to be rounded into a circle.
• The content message displays next to the avatar.

Similar to the above, create a SwiftUI file and name it MessageView

var body: some View {
    HStack(alignment: .bottom, spacing: 15) {
        Image("My-avatar")
            .resizable()
            .frame(width: 40, height: 40, alignment: .center)
            .cornerRadius(20)
        ContentMessageView(contentMessage: "There are a lot of premium iOS templates on iosapptemplates.com",
                          isCurrentUser: false)
    }
}

While coding, you can see the UI will be constantly updated in the Canvas view (on the right side). This is one of the most popular SwiftUI features (live previews).

It looks good, right? So what about the sender? According to the current UX, the sender's message will be on the trailing side and no avatar. At this step, we need a variable to check current user information in order to update the UI properly. As a side note, if/else or switch/case conditions can only live in HStack/VStack/Group or similar components. After combining the values and conditions, our code will look like this

struct MessageView : View {
    var currentMessage: Message
    var body: some View {
        HStack(alignment: .bottom, spacing: 15) {
            if !checkedMessage.user.isCurrentUser {
                Image(checkedMessage.user.avatar)
                    .resizable()
                    .frame(width: 40, height: 40, alignment: .center)
                    .cornerRadius(20)
            } else {
                Spacer()
            }
            ContentMessageView(contentMessage: checkedMessage.content,
                              isCurrentUser: checkedMessage.user.isCurrentUser)
        }
    }
}

If you would love to see how it displays, let's update code in the previews section as follows:

struct MessageView_Previews: PreviewProvider {
    static var previews: some View {
        MessageView(currentMessage: Message(content: "There are a lot of premium iOS templates on iosapptemplates.com", user: DataSource.secondUser))
    }
}

3. Chat View​

In an actual real Xcode project, the messages will be stored on the server for synchronization between all users. In this tutorial, we are going to simulate the server by using an array function containing messages named DataSource. Each generated message will be appended to this array (this action is like sending a message to the server). And to do that, we'll create a helper class – and name it ChatHelper, to separate concerns appropriately. The didChange variable is used to fire a signal whenever a new message is created. Welcome to the world of reactive programming, now natively built into Swift.

class ChatHelper : ObservableObject {
    var didChange = PassthroughSubject<Void, Never>()
    @Published var realTimeMessages = DataSource.messages

    func sendMessage(_ chatMessage: Message) {
        realTimeMessages.append(chatMessage)
        didChange.send(())
    }
}

Now, we will go to the main content of this section – Chat View. Let's create a file named ChatView and declare the following properties:

@State var typingMessage: String = ""
@EnvironmentObject var chatHelper: ChatHelper

typingMessage is the latest message that was lastly typed in by the user, and chatHelper is an object that manages and retrieves the data (our mock API object introduced above). Next, move to the body section, add the following lines of SwiftUI code:

VStack {
    List {
        ForEach(chatHelper.realTimeMessages, id: \.self) { msg in
            MessageView(checkedMessage: msg)
        }
    }
    HStack {
        TextField("Message...", text: $typingMessage)
            .textFieldStyle(RoundedBorderTextFieldStyle())
            .frame(minHeight: CGFloat(30))

        Button(action: sendMessage) {
            Text("Send")
        }
    }.frame(minHeight: CGFloat(50)).padding()
}

Well, obviously, SwiftUI makes our code much easier to read and visualize. We will not explain anything in the above code to challenge you. Your challenge is to visualize our screen from that block of code. Not a big deal, right? Important note: Because we use List, Message and User we need to implement the Hashable protocol to uniquely identify each row in the list.

struct Message: Hashable {...}
struct User: Hashable {...}

To make the UI more eye-catching, perhaps we won't need separator lines, you can do the following

init() {
    UITableView.appearance().separatorStyle = .none
    UITableView.appearance().tableFooterView = UIView()
}

And here is the sendMessage function:

func sendMessage() {
    chatHelper.sendMessage(Message(content: typingMessage, user: DataSource.secondUser))
    typingMessage = ""
}

Next, for someone who has been working with iOS for a long time like you, leaving the navigation blank is very annoying, isn't it? Let us help you.

NavigationView {
    VStack{...}
        .navigationBarTitle(Text(DataSource.firstUser.name), displayMode: .inline)
}

Believe it or not, you're going to get to the destination. What we need to do is updating some configuration in the SceneDelegate file. At the first line inside the willConnectTo function, declare an environmentObject:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions){
    let chatHelper = ChatHelper()
}

Inside the same function, we are going to tell the compiler our rootViewController is UIHostingController(rootView: chatView.environmentObject(chatHelper))

let chatView = ChatView()

// Use a UIHostingController as window root view controller.
if let windowScene = scene as? UIWindowScene {
    let window = UIWindow(windowScene: windowScene)
    window.rootViewController = UIHostingController(rootView: chatView.environmentObject(chatHelper))
    self.window = window
    window.makeKeyAndVisible()
}

Now, let's compile and run our screen.

Conclusion​

That's it. Building a SwiftUI chat app for iOS is not as hard as it looks like. Of course with a real chat application, everything will be a lot more complex for sure. But for the purposes of this tutorial, you and we can feel how much SwiftUI has helped us. Indeed, if done with UIKit, we will certainly take a lot more time and effort for repetitive, not meaningful tasks (especially for experienced people) such as drag and drop, register cell, reusing cells, caching images, etc. Hopefully you have learned something more interesting about SwiftUI from this hands-on experience rather than the sterile academic theory. Here is the complete source code on Github (Please give us a Star ❤️️ ). And stay tuned! In the next tutorial, we will continue to improve this SwiftUI chat app!

For iOS developers, setting up UI programmatically might feel hard and complicated, especially if you are not very experienced in Swift. But luckily, there are a lot of libraries supporting us with this problem. One of them is SnapKit. In our mobile app templates, we use SnapKit to set up UI programmatically, since it’s by far the best Swift UI Layout Library. In this SnapKit tutorial, we are going to give you a brief introduction to the SnapKit world.

In this SnapKit tutorial, we are describing our experience of working with SnapKit to help you learn how to simplify auto layout in iOS App Development.

1. Introduction to SnapKit​

For iOS programmers, the “Auto-layout” term is extremely familiar. It almost becomes a required part when implementing layout for mobile applications. Currently, there are two streams of ideas at play. One must decide whether to use Interface Builder for implementing layout or do it programmatically. When using Interface Builder, we can add all constraints by using storyboards or xib files, and in that case, our code will be less complicated, since fewer lines of code would be used and the time to write all this code would be discounted. It would be just “drag-drop” stuff.

However, the bigger and more complex your project gets and the higher the number of interface files you have, the more difficult it is to manage these files. And then, if you need some dynamic layouts, you have to drag many constraints to update the UI correspondingly. It makes your project hard to debug and hard to control. And like this is not enough, imagine now that you have a ton of iOS developers working on the same project, so a lot of other problems arise with that, such as merge conflict on autogenerated files. Ugly, right?

So, either way, you have to know how to do auto layout programmatically, since if your app becomes successful, this will be a requirement down the road.

But the biggest disadvantage of using Auto Layout programmatically is that it takes too long. You’ll have to write a ton of code to set constraints instead of a few mouse clicks. Apple’s Auto Layout is extremely verbose and time-consuming to write. SnapKit helps us address this problem, by providing a concise abstraction of Apple’s Auto Layout Constraints system.

2. SnapKit and Usage​

SnapKit is a tool allowing iOS developers to manipulate auto-layout constraints easily. By using SnapKit, you can create, update, remove and manage layout constraints of the UI views.

Let’s consider some examples, to give you an idea of how concise and clear SnapKit is, as opposed to Apple’s Cocoa Auto-Layout library. First of all, you need to install SnapKit via CocoaPods (a dependency manager). Add this to your Podfile:

pod 'SnapKit'

And to save time and ink (lol), we won’t talk CocoaPods and the Podfile. They belong to another article, so feel free to Google it.

Do you remember how to add constraints programmatically? For example, if we want to vertically center a view, the code will be something like this:

let horizontalConstraint = NSLayoutConstraint(
    item: view,
    attribute: NSLayoutConstraint.Attribute.centerX,
    relatedBy: NSLayoutConstraint.Relation.equal,
    toItem: view,
    attribute: NSLayoutConstraint.Attribute.centerX,
    multiplier: 1,
    constant: 0
)

Oops, that looks ugly. We don’t even want to think about it, let alone write them down. Let’s see how SnapKit solves this huge pain point for Swift developers.

Let’s display a UIView pinned to the four edges of its superview. So, just imagine we have four constraints such as the one above, with a lot of messy code. Let’s see how SnapKit handles this scenario.

Step 1: Create a UIView programmatically​

Imagine we have a blank view controller in a new Xcode project. In viewDidLoad(), we have some of the following lines of code:

let childView = UIView()
childView.backgroundColor = .red
self.view.addSubview(childView)

It is basically creating a new view, setting the background color for it and adding it into the view. That’s all there is to it.

Step 2: Use SnapKit​

First of all, we need to import this library.

import SnapKit

And let’s continue to write codes inside viewDidLoad()

childView.snp.makeConstraints { (make) in
  make.top.bottom.left.right.equalTo(self.view)
}

Now, let’s build and run the Xcode sample project:

It’s really simple, right?! Literally, with one line, we have made all four edges of the childView equal to the edges of the super.view. If you compare this with the code we showed in the previous section, this is a much more concise approach. So you are already saving a ton of time while coding UI. But that’s not all. We can even refactor this code on step further:

childView.snp.makeConstraints { (make) in
  make.edges.equalTo(self.view)
}

Now re-run and you can see we pinned four edges using just one single line of code, instead of twenty or thirty lines like we showed before.

3. More SnapKit Examples​

Let’s continue with another SnapKit example. We will create another view, called anotherChildView:

let anotherChildView = UIView()
anotherChildView.backgroundColor = .yellow
self.view.addSubview(anotherChildView)

Let’s try new things in SnapKit:

childView.snp.makeConstraints { (make) in
  make.size.equalTo(CGSize(width: 300, height: 300))
  make.top.equalTo(self.view.snp.top).offset(100)
  make.centerX.equalTo(self.view)
}
anotherChildView.snp.makeConstraints { (make) in
  make.size.equalTo(childView)
  make.top.equalTo(childView.snp.bottom).offset(50)
  make.centerX.equalTo(self.view)
}

As you can see, we have a lot of functions

• size.equalTo
• top.equalTo (Likewise, we have bottom.equalTo, left.equalTo and right.equalTo) with the offset.
• **centerX.**equalTo and centerY.equalTo with the offset.

Besides these, SnapKit also has .multipliedBy. You can use this function to create the aspect ratio for the views. Because these lines of code are quite easy and straightforward, we will not dig into the implementation details. You could refer to SnapKit.io website as its documentation is really detailed and easy to follow.

Now let’s run this once more.

It worked as expected. In addition, SnapKit also supports us with debugging. It will show us exactly the views for which the constraints are broken. We can then easily check and update those constraints correspondingly.

Conclusion on SnapKit​

After reading this SnapKit Tutorial, we hope you can see the benefits of SnapKit for setting up UI programmatically. It allows you to write less code, which in turn makes the whole process much simpler. As a small downside, however, we still need to continue to learn how to use Auto-layout programmatically with the available iOS APIs (because SnapKit is just a third-party library, which someday may not be supported anymore – this is highly unlikely since there’s a huge iOS Community around the SnapKit open-source project).

Overall, SnapKit is a useful library if you want to improve your code when making constraints programmatically. Your Xcode project will get more concise and more modularized, which is exactly the reason why we are heavily using SnapKit in our iOS Starter Kits. Here is the source code for this SnapKit Tutorial. Happy Coding!

Over the past few years, along with the popularity of social networking applications, dating apps have also rapidly emerged. One of these most prominent applications is Tinder. It’s not only an awesome dating app, but it also created new iOS trends on view animations or transitions, such as the Tinder Card Swipe or Tinder UI (our Swift Dating App was inspired by Tinder).

In this iOS tutorial, we are going to learn how to build the Tinder Swipe Cards in Swift, so that you can include this feature into your iOS apps. There are currently a few libraries supporting this type of swipeable cards and one of them is KolodaView. In this tutorial, we’ll show you how to implement this animation in Swift, with code examples.

1. Introduction​

To learn general details about the Koloda View library, you can refer to its official documentation here. In this part, we’ll just give you a high-level overview of it. The highlight of this library is the swipe-to-like interface inspired by Tinder. The team did a great job of explaining how to design the UI and how it works. You can read their tutorials to understand more about their mechanism of action. Koloda View library uses the same the dataSource and delegate design patterns, by leveraging protocols. These patterns were inspired from the UITableView and UICollectionView design. It’s really convenient for iOS engineers to use this library, given they are already familiar with the overall architectural patterns. All we need to do is to conform our view controller to two protocols, and handle the necessary functions. Now let’s get started to learn concretely how to build an app like Tinder, by leveraging Koloda View for the Tinder-esque card interface.

2. Building the iOS Tinder Cards in Swift​

First of all, since this is a third-party library, you need to install it from Carthage, CocoaPod or manually (“drag-drop” stuff), in order to include it as a dependency to your Xcode project. We’ll install KolodaView via CocoaPods, as usual. So add to your Podfile the following pod dependency:

pod "Koloda"

Let’s run the newly created Xcode project and then write the code on the workspace with the same name. Our theme for this Swift tutorial will be about Marvel’s heroes. When we are writing this article, the whole world is going crazy over Endgame – the movie of the decade so we want to make this as a tribute about a long journey as well as our Iron Man. If you’re not familiar with the movie, no worries, you’ll understand the tutorial entirely anyway. Now, let’s write some code.

Step 1: Setting up Tinder UI​

By using the Interface Builder, drag a UIView object to your storyboard. Add constraints for it (you can refer to our way or add your own constraints). In the Identity Inspector, we set a custom class (KolodaView) for our UIView object as follows:

Pay attention to set the Module as Koloda, otherwise, your app will instacrash. After that, drag an IBOutlet connection from the UIView on the screen to the UIViewController. Do not forget to import the Koloda library, so that the code compiles successfully.

Step 2: Conform to DataSource and Delegate Protocols​

In the viewDidLoad of your view controller, let’s add the following code snippet:

override func viewDidLoad() {
    super.viewDidLoad()

    kolodaView.dataSource = self
    kolodaView.delegate = self
  }
}

As we said, the way we conform to these protocols is the same way we’ve always done with UITableView or UICollectionView. We’ve separated the KolodaView delegate/dataSource into their own extensions to make it easier to explain:

extension ViewController: KolodaViewDelegate {
  func kolodaDidRunOutOfCards(_ koloda: KolodaView) {
    koloda.reloadData()
  }

  func koloda(_ koloda: KolodaView, didSelectCardAt index: Int) {
    let alert = UIAlertController(title: "Congratulation!", message: "Now you're \(images[index])", preferredStyle: .alert)
    alert.addAction(UIAlertAction(title: "OK", style: .default))
    self.present(alert, animated: true)
  }
}
extension ViewController: KolodaViewDataSource {

  func kolodaNumberOfCards(_ koloda:KolodaView) -> Int {
    return images.count
  }

  func koloda(_ koloda: KolodaView, viewForCardAt index: Int) -> UIView {
    let view = UIImageView(image: UIImage(named: images[index]))
    view.layer.cornerRadius = 20
    view.clipsToBounds = true
    return view
  }
}

As you can see, the two delegate methods inside KolodaViewDataSource look the same as UITableViewDataSource’s functions. In there, we declare the numbers of items (Tinder Cards) and how they will be displayed. For KolodaViewDelegate, you’ll handle performing actions on each item (on each swipeable card). These are just a few basic examples. In fact, you can use a lot of protocol methods supported by this library as follows: For KolodaViewDataSource:

- func kolodaSpeedThatCardShouldDrag(_ koloda: KolodaView) -> DragSpeed
- func koloda(_ koloda: KolodaView, viewForCardOverlayAt index: Int) -> OverlayView?

There is a side note here, to set the custom overlay action on swiping (left/right), you should override didSet of overlayState property in OverlayView. For KolodaViewDelegate, you can find out in its documentation all the protocols supported by this library. In this iOS tutorial, we would like to mention some of the protocols that we feel are the most important.

func kolodaDidRunOutOfCards(_ koloda: KolodaView)

This function is so noteworthy because you can not leave your UI empty after the view runs out of cards. You have to handle this scenario such as hiding the Koloda or showing a view that’s telling users that there are no more cards. Remember, treating your empty states graciously is a sign of awesome design skills, and makes your mobile app stand out from the crowd.

func koloda(_ koloda: KolodaView, didSelectCardAt index: Int)

This function is called when users tap on a Tinder card (similar to didSelectRowAt of UITableViewDelegate). In our iOS app example, we showed an alert, for example. The rest of the delegate methods refer mostly to animations, so you should carefully research them, to make your dating app richer in visual features. Now, let’s run the app to see our heroes.

Conclusion​

Alright! We built a simple Tinder UI Card Swipe Swift with KolodaView successfully. In the near future, this behavior will become increasingly common, so we hope you’ll like this article. Download the complete source code here (since we update some UIs to make the UI better and don’t forget to run pod install before opening it up). Don’t forget to share this article if you’ve enjoyed it. Also, if you’re looking to build your own dating app, you can skip a few weeks of design & development, by buying our dating app template. Happy Coding! PS: All images used in this project is downloaded here: https://www.pixelstalk.net/thor-backgrounds-free.

WebRTC (Web Real-Time Communication) is a powerful technology that enables real-time communication (like video and voice chats) in web and mobile applications. Integrating WebRTC into iOS applications often involves a combination of the native WebRTC SDK and bridging techniques to adapt it for specific platforms like SwiftUI or UIKit.

In this brief guide, I'll walk you through the process of setting up WebRTC for an iOS application using Swift:

1. Setting Up the WebRTC SDK​

To start, you need the WebRTC framework for iOS:

• You can either compile it from source (which can be time-consuming) or fetch precompiled binaries.
• Check out popular GitHub repositories that offer these precompiled frameworks for easier integration.

2. Initialize WebRTC​

First, set up your view controller or SwiftUI view for video display:

import UIKit
import WebRTC

class VideoViewController: UIViewController {
    var remoteVideoTrack: RTCVideoTrack?
    var remoteVideoView: RTCEAGLVideoView?

    override func viewDidLoad() {
        super.viewDidLoad()

        self.remoteVideoView = RTCEAGLVideoView(frame: self.view.frame)
        if let remoteVideoView = self.remoteVideoView {
            self.view.addSubview(remoteVideoView)
        }
    }
}

3. Set Up RTCPeerConnection​

RTCPeerConnection is a key component in WebRTC. It represents the connection between peers.

let configuration = RTCConfiguration()
let peerConnection = peerConnectionFactory.peerConnection(with: configuration, constraints: nil, delegate: nil)

4. Handle Offer and Answer​

For peers to connect, one needs to create an offer, and the other should answer:

// Creating an offer
peerConnection.offer(for: RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil)) { (sdp, error) in
    guard let sdp = sdp else { return }
    // Send this sdp to the other peer using your signaling server
}

// Setting remote description and creating an answer
func receivedOfferFromPeer(offerSDP: String) {
    let remoteSDP = RTCSessionDescription(type: .offer, sdp: offerSDP)
    peerConnection.setRemoteDescription(remoteSDP) { (error) in
        guard error == nil else { return }
        peerConnection.answer(for: RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil)) { (sdp, error) in
            guard let sdp = sdp else { return }
            // Send this sdp back to the offerer using your signaling server
        }
    }
}

5. Signal Handling​

WebRTC does not define how signaling should be done, but it's an essential component. You might want to use WebSockets, Firebase, or any other communication mechanism to exchange offers, answers, and ICE candidates between peers.

6. Handle ICE Candidates​

For NAT traversal, you need to handle ICE candidates:

func peerConnection(_ peerConnection: RTCPeerConnection, didGenerate candidate: RTCIceCandidate) {
    // Send this candidate to the other peer using your signaling server
}

func receivedICECandidateFromPeer(candidate: RTCIceCandidate) {
    peerConnection.add(candidate)
}

7. Displaying Video​

When receiving a video track:

func peerConnection(_ peerConnection: RTCPeerConnection, didAdd stream: RTCMediaStream) {
    if let videoTrack = stream.videoTracks.first {
        videoTrack.add(remoteVideoView)
    }
}

Conclusion​

Setting up WebRTC on iOS requires careful coordination between signaling, session establishment, and media handling. Once set up, WebRTC provides a robust solution for real-time communication in your app. Remember that you also need a STUN/TURN server for NAT traversal, especially for production applications. There are various platforms and services (like Twilio, Agora.io, etc.) that offer easy integration for WebRTC on iOS if you'd like to avoid setting up everything from scratch.

SwiftUI has revolutionized iOS app development by offering a declarative and intuitive way to build user interfaces. To further enhance your SwiftUI development experience and make your apps stand out, various third-party libraries have emerged. In this blog post, we'll dive into 10 SwiftUI libraries that can supercharge your iOS app development journey. Each library comes with a code example explained line by line to help you understand its implementation.

1. AlamofireImage​

AlamofireImage is an image downloading and caching library built on top of Alamofire, simplifying the process of fetching and caching images. It provides features like automatic caching, image decompression, and prioritized downloading.

Example​

import SwiftUI
import AlamofireImage

struct ImageView: View {
    var body: some View {
        VStack {
            Text("AlamofireImage Example")
            Image(uiImage: UIImage(named: "placeholder")!)
                .resizable()
                .aspectRatio(contentMode: .fit)
                .frame(width: 200, height: 200)
                .afImageCache()
        }
    }
}

2. Kingfisher​

Kingfisher is another powerful image downloading and caching library that is widely used in the iOS community. It supports various image formats, caching strategies, and customizable loading indicators.

Example​

import SwiftUI
import Kingfisher

struct ImageViewWithKingfisher: View {
    var body: some View {
        VStack {
            Text("Kingfisher Example")
            KFImage(URL(string: "https://example.com/image.jpg"))
                .resizable()
                .aspectRatio(contentMode: .fit)
                .frame(width: 200, height: 200)
        }
    }
}

3. SDWebImageSwiftUI​

SDWebImageSwiftUI is an integration of the popular SDWebImage library into SwiftUI. It provides asynchronous image loading, caching, and displaying with support for placeholder images and image transformation.

Example​

import SwiftUI
import SDWebImageSwiftUI

struct WebImageView: View {
    var body: some View {
        VStack {
            Text("SDWebImageSwiftUI Example")
            WebImage(url: URL(string: "https://example.com/image.jpg"))
                .resizable()
                .aspectRatio(contentMode: .fit)
                .frame(width: 200, height: 200)
        }
    }
}

4. ViewInspector​

ViewInspector is a library that enables SwiftUI view hierarchy introspection, helping developers with debugging and UI testing. It allows you to access and modify the properties of a SwiftUI view.

Example​

import SwiftUI
import ViewInspector

struct InspectableView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("ViewInspector Example")
            Text("Count: \(count)")
        }
        .onTapGesture {
            count += 1
        }
        .inspect { view in
            try view.find(ViewType.Text.self, "Count: 0")
        }
    }
}

5. SwiftUIX​

SwiftUIX is a collection of extensions and utilities that expand the capabilities of SwiftUI. It provides additional components, modifiers, and functionality not present in the standard SwiftUI library.

Example​

import SwiftUI
import SwiftUIX

struct ExtendedView: View {
    var body: some View {
        VStack {
            Text("SwiftUIX Example")
            Button(action: {}) {
                Label("Submit", systemImage: "arrow.right.circle.fill")
            }
            .buttonStyle(PlainButtonStyle())
        }
    }
}

6. Pulley​

Pulley is a versatile library that simplifies the creation of custom drawer and bottom sheet interfaces. It provides a smooth and interactive experience for users to reveal additional content.

Example​

import SwiftUI
import Pulley

struct PulleyView: View {
    var body: some View {
        PulleyView(content: Text("Main Content")) {
            Text("Drawer Content")
                .frame(maxWidth: .infinity, maxHeight: .infinity)
                .background(Color.gray)
        }
    }
}

7. AlertToast​

AlertToast offers an elegant way to display toast messages and alerts in SwiftUI applications. It supports various customization options and animations for presenting messages to users.

Example​

import SwiftUI
import AlertToast

struct ToastView: View {
    @State private var showToast = false

    var body: some View {
        VStack {
            Text("AlertToast Example")
            Button("Show Toast") {
                showToast = true
            }
            .alertToast(isPresented: $showToast, alert: {
                AlertToast(type: .complete(.green), title: "Success")
            })
        }
    }
}

8. SwiftEntryKit​

SwiftEntryKit is a flexible library for displaying custom popup alerts, banners, and notifications in your SwiftUI app. It supports various presentation styles and animations.

Example​

import SwiftUI
import SwiftEntryKit

struct CustomPopupView: View {
    var body: some View {
        VStack {
            Text("SwiftEntryKit Example")
            Button("Show Popup") {
                showCustomPopup()
            }
        }
    }

    func showCustomPopup() {
        var attributes = EKAttributes.centerFloat
        attributes.entryBackground = .color(color: .white)
        let customView = YourCustomPopupView()
        SwiftEntryKit.display(entry: customView, using: attributes)
    }
}

9. Motion​

Motion is a library that adds smooth animations and transitions to your SwiftUI views. It simplifies the process of creating complex animations and adds delightful user interactions.

Example​

import SwiftUI
import Motion

struct AnimatedView: View {
    @State private var scale: CGFloat = 1.0

    var body: some View {
        VStack {
            Text("Motion Example")
            Circle()
                .frame(width: 100, height: 100)
                .scaleEffect(scale)
                .onTapGesture {
                    withAnimation(.spring()) {
                        scale = scale == 1.0 ? 1.5 : 1.0
                    }
                }
        }
    }
}

10. ColorPicker​

The ColorPicker library provides a SwiftUI color picker view, allowing users to select colors easily. It supports a wide range of customization options and integrations.

Example​

import SwiftUI
import ColorPicker

struct ColorPickerView: View {
    @State private var selectedColor: Color = .red

    var body: some View {
        VStack {
            Text("ColorPicker Example")
            ColorPicker("", selection: $selectedColor)
                .frame(width: 100, height: 100)
        }
    }
}

Conclusion​

These 10 SwiftUI libraries offer a wide range of functionalities to enhance your iOS app development journey. Whether you're looking to improve image handling, add animations, or customize UI components, these libraries have got you covered. By integrating these libraries into your projects, you can significantly speed up your development process and create more polished, feature-rich applications.

Xcode, Apple's primary development environment, offers a multitude of shortcuts to boost your productivity. Familiarizing yourself with these shortcuts can significantly speed up your development process. In this tutorial, we'll delve into the top Xcode shortcuts every iOS developer should have in their arsenal.

Navigating Files and Code​

1. Jump to Definition​

• Shortcut: Cmd + Click on a method/variable

• This shortcut enables you to quickly navigate to the definition of a method, class, or variable.

func exampleFunction() {
    print("Hello, World!")
}

Just Cmd + Click on exampleFunction anywhere it's used to jump to its definition.

2. Open Quickly​

• Shortcut: Cmd + Shift + O

• This opens a dialog where you can quickly find and open any file or symbol.

// Type the name of the file or symbol in the dialog
// E.g., "ViewController.swift"

3. Switch Between Header and Implementation​

• Shortcut: Cmd + Ctrl + Up/Down Arrow

• Toggle between the header .h file and its corresponding implementation .m or .swift file.

// ViewController.h
@interface ViewController : UIViewController
@end

// ViewController.m
@implementation ViewController
@end

Editing Code​

1. Comment / Uncomment Code​

• Shortcut: Cmd + /

• Quickly comment out a line or a selected block of code.

// Cmd + / will toggle commenting for the selected lines
print("This line is commented")
// print("This line is uncommented")

2. Duplicate Lines​

• Shortcut: Cmd + D

• Duplicate the current line or selected block.

print("Original line")
print("Original line") // Duplicate using Cmd + D

3. Delete Line​

• Shortcut: Cmd + Delete

• Removes the current line or selected block.

print("This line will be deleted") // Use Cmd + Delete

Debugging​

1. Toggle Breakpoint​

• Shortcut: Cmd + \

• Set or remove a breakpoint on the current line.

func debugFunction() {
    print("Breakpoint here") // Cmd + \ to toggle breakpoint
}

2. Activate/Deactivate All Breakpoints​

• Shortcut: Cmd + Y

• Control all the breakpoints in your project with a single command.

Interface Builder​

1. Zoom In/Out on Interface Builder Canvas​

• Shortcut: Cmd + = or Cmd + -

• Adjust your view of the Interface Builder canvas to see more or less detail.

// No code snippet needed. Use this directly in the Interface Builder

2. Toggle Sidebar in Interface Builder Shortcut: Cmd + 0​

Quickly hide or reveal the sidebar in Interface Builder for a broader view of your canvas.

Simulator Controls​

1. Rotate Simulator Left/Right​

• Shortcut: Cmd + Left Arrow or Cmd + Right Arrow

• Rotate your simulator to landscape or portrait orientations.

// No code snippet needed. Use this directly in the ios Simulator.

2. Go Home in Simulator​

• Shortcut: Cmd + Shift + H

• Mimic the "Home" button press on devices without a physical button.

// No code snippet needed. Use this directly in the ios Simulator.

Conclusion​

Mastering these shortcuts will streamline your iOS development in Xcode. Practice using them until they become second nature, and you'll find your efficiency significantly improved. Happy coding!

If you’re building an application in SwiftUI and looking to incorporate web content directly into your app, a WebView is what you need. In this tutorial, we’ll walk through how to create and customize a WebView in SwiftUI.

Introduction​

SwiftUI, Apple’s declarative UI framework, does not have a built-in WebView. However, SwiftUI allows you to integrate UIKit views, meaning we can use the WKWebView from the WebKit framework to create a WebView. Let’s learn how to do this.

Getting Started: Integrating WKWebView with SwiftUI​

First, we need to create a SwiftUI View that represents a WKWebView. We can do this using the UIViewRepresentable protocol:

import SwiftUI
import WebKit

struct WebView: UIViewRepresentable {
    let url: URL

    func makeUIView(context: Context) -> WKWebView {
        let webView = WKWebView()
        webView.load(URLRequest(url: url))
        return webView
    }

    func updateUIView(_ uiView: WKWebView, context: Context) {
        // This space can be left blank
    }
}

This WebView struct takes a URL and creates a WKWebView that loads that URL.

Customizing the WebView​

To customize our WebView, we can make use of the various delegate methods provided by WKWebView.

WebView Navigation Delegate​

To track the loading progress of a webpage or handle navigation decisions, we can use the WKNavigationDelegate. Let’s update our WebView struct to include a Coordinator class that acts as the navigation delegate:

struct WebView: UIViewRepresentable {
    let url: URL

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    func makeUIView(context: Context) -> WKWebView {
        let webView = WKWebView()
        webView.navigationDelegate = context.coordinator
        webView.load(URLRequest(url: url))
        return webView
    }

    func updateUIView(_ uiView: WKWebView, context: Context) {
        // This space can be left blank
    }

    class Coordinator: NSObject, WKNavigationDelegate {
        let parent: WebView

        init(_ parent: WebView) {
            self.parent = parent
        }

        func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
            print("Webview started loading.")
        }

        func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
            print("Webview finished loading.")
        }

        func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
            print("Webview failed with error: \(error.localizedDescription)")
        }
    }
}

Now, whenever a webpage starts loading, finishes loading, or fails to load, the corresponding message will be printed to the console.​

Using the WebView in your SwiftUI App Using the WebView in your app is as simple as using any other SwiftUI View. Here’s an example:

struct ContentView: View {
    var body: some View {
        WebView(url: URL(string: "https://www.example.com")!)
    }
}

Wrapping Up​

In this tutorial, we learned how to use a WebView in SwiftUI, and how to customize it to track webpage loading status. By leveraging the power of UIViewRepresentable, we can integrate virtually any UIKit view into our SwiftUI apps.

Please note that the above code has been written with Swift 5.3 and SwiftUI 2.0. If you’re using a different version, the code may need adjustments.

Conclusion​

Now that you’ve mastered the basics of using a WebView in SwiftUI, you’re all set to include web content in your iOS applications more smoothly. This could include anything from loading websites to interacting with HTML interfaces directly within your application. Through the use of SwiftUI and WebKit, Apple has opened up vast possibilities for enhancing your app’s user experience.

Hello fellas, welcome back to our SwiftUI series. In the previous few tutorials, you learned a lot about components, operators as well as how to work with UIKit. Now, it’s time to put those skills to work and get your hands dirty with real practice – design a catchy Login Screen in SwiftUI. After this article, you will find SwiftUI much more convenient and clear.

Along with that, it’s time to break up with our beloved UIViewController. Goodbye old friend, we had a really good time, right?

With a declarative, data-driven language like SwiftUI, your imagination will almost be “printed” onto the phone screen in a few minutes. Let’s take our Login screen as an example. I’d like you all to close your eyes, please … and imagine: we have a big title, then an image, text fields, and so on. Now open your eyes. BOOM!

Yeah, I know that feeling. Feel like reach for the stars, right? Let’s now look under the hood to see how this magic works.

1. Build the Skeleton​

Add this block of code inside body property. Also, declare two properties as follows:

// MARK: - Propertiers
@State private var email = ""
@State private var password = ""

// MARK: - View
var body: some View {
  VStack() {
    Text("iOS App Template")
    Image("iosapptemplate")
    TextField("Email", text: self.$email)
    TextField("Password", text: self.$password)
    Button("Sign In") {}
  }
}

The above code is so easy to understand that a person who has never been exposed to SwiftUI (not even to iOS programming) can have a rough idea of what our app is doing. We declare the components that we want and trust SwiftUI that it will help with rendering the UI part.

Believe it or not, we are halfway there already. The next part is just reorganizing the structure and re-styling the components to create an eye-catching screen.

2. Reorganize the structure and style our components​

a. Textfields​

Change two textfields as follows

VStack {
  TextField("Email", text: self.$email)
  SecureField("Password", text: self.$password)
}

We should put the text fields on the same stack for easy control. Normally, in screens during the Authentication stage (such as Login, SignUp), text fields often have the same frames or constraints, for a great UI & UX. Let’s give a try.

VStack(alignment: .leading, spacing: 15) {

  TextField("Email", text: self.$email)
    .padding()
    .background(themeTextField)
    .cornerRadius(20.0)

  SecureField("Password", text: self.$password)
    .padding()
    .background(themeTextField)
    .cornerRadius(20.0)
}.padding([.leading, .trailing], 27.5)

As you can see, the parts like padding or spacing of these text fields are the same. Instead of having to configure each one, we put all the text fields into VStack and just do it on this component itself.

b. Texts and Images​

Basically, this section does not have too many details to talk about. If you look at their definitions, you can see the APIs that you need. Also, right-click on the Previews section will also update our code directly. Now let’s try some text and image modifiers.

Text("iOS App Template")
  .font(.largeTitle).foregroundColor(Color.white)
  .padding([.top, .bottom], 40)

Image("iosapptemplate")
  .resizable()
  .frame(width: 250, height: 250)
  .clipShape(Circle())
  .overlay(Circle().stroke(Color.white, lineWidth: 4))
  .shadow(radius: 10)
  .padding(.bottom, 50)

c. Buttons​

In the first piece of code, you might have noticed one of the Button declarations. Very easy to understand, right? We usually divide a Button into two parts, part one being its action. And part two is where we will layout all of it.

Button(action: {}) {
  Text("Sign In")
    .font(.headline)
    .foregroundColor(.white)
    .padding()
    .frame(width: 300, height: 50)
    .background(Color.green)
    .cornerRadius(15.0)
}

d. Color Gradient​

By now basically everything is done, the next step is to “color” them. In this section, we will also show you how to use gradient colors. Add the following code in the closing curly bracket of the biggest VStack to the following code.

.background(
  LinearGradient(gradient: Gradient(colors: [.purple, .blue]), startPoint: .top, endPoint: .bottom)
    .edgesIgnoringSafeArea(.all))

We used the Gradient object with purple and blue to blend and the gradient color to be blended from top to bottom. Gradient(colors: [.purple, .blue]), startPoint: .top, endPoint: .bottom).

Everything is fine now except for one thing. Our VStack doesn’t fill up the entire screen. Here is the tip. Add Spacer() inside the VStack, it will make the VStack fill the height of the screen.

We can make it more eye-catching with a shadow for each component. Now, let’s build and run the app to enjoy the fruits of our labor.

3. Where to go from here?​

You now you know how to build a complex UI containing TextFields, Texts, Images, and Buttons, but there’s plenty more you can do, including authenticating emails or passwords, show an alert to tell users if they logged in successfully or failed.

I hope you learned something new in this tutorial. Since a lot of stuff about SwiftUI is coming, make sure you do not miss any updates in this series. If you have any concerns or questions, feel free leave a comment below! And don’t forget to give us 1 star on Github. Thanks so much.

Welcome back to a new tutorial of our SwiftUI series. In this tutorial, we are going to learn how to implement a navigation drawer in SwiftUI, also know as side menu, side bar menu or hamburger menu. If you have ever worked with it in UIKit, you will understand its nature thoroughly. We will simply create a ViewController and assign it as a quick navigator.

Before getting into it, we would like to make sure that you do not miss any of our previous articles related to SwiftUI – they are extremely clear, concise and helpful. Let's get started.

1. Create the Navigation Drawer SwiftUI Component​

In this first step, we are going to create two things. The first one is the content of the navigation drawer. This will usually be a list of screens that users can navigate to. You could see an example in the image below. This is one of our templates where we implemented the navigation drawer.

To keep this tutorial simple, we only create a simple view with a background color. Here's the SwiftUI code snippet:

struct DrawerContent: View {
    var body: some View {
        Color.blue
    }
}

The second part is the underlying padding. Its responsibility is to take care of tasks such as frames, transitions, opacities, borders, etc. In general, one view can do both tasks, but it's better to split it up because the DrawerContent view can be very complex.

struct NavigationDrawer: View {
    private let width = UIScreen.main.bounds.width - 100
    let isOpen: Bool
    
    var body: some View {
        HStack {
            DrawerContent()
                .frame(width: self.width)
                .offset(x: self.isOpen ? 0 : -self.width)
                .animation(.default)
            Spacer()
        }
    }
}

Through the above code, we achieve the following:

• We embedded our DrawerContent inside NavigationDrawer through a HStack.
• We've also made the frame for it. You can adjust the width as you want. isOpen is a property telling us if our navigation drawer is currently visible or not. Changing this flag will also change the visibility of the navigation drawer menu accordingly.

2. Adding the Navigation Drawer to the ContentView​

In this step, all that's left to do is to add the ability to call this function from the main view – our ContentView.

Add this block of SwiftUI code into the ContentView's body:

struct ContentView: View {
    @State var isDrawerOpen: Bool = false
    
    var body: some View {
        ZStack {
            /// Navigation Bar Title part
            if !self.isDrawerOpen {
                NavigationView {
                    EmptyView()
                        .navigationBarTitle(Text("Navigation Drawer"))
                        .navigationBarItems(leading: Button(action: {
                            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
                                self.isDrawerOpen.toggle()
                            }
                        }) {
                            Image(systemName: "sidebar.left")
                        })
                }
            }

            /// Navigation Drawer part
            NavigationDrawer(isOpen: self.isDrawerOpen)

            /// Other behaviors
        }.background(Color.white)
        .onTapGesture {
            if self.isDrawerOpen {
                self.isDrawerOpen.toggle()
            }
        }
    }
}

Don't panic! This block of code looks quite wordy but it is relatively simple. We're going to explain it step by step.

First, let's take a look at the block of code including the NavigationView below.

NavigationView {
    EmptyView()
        .navigationBarTitle(Text("Navigation Drawer"))
        .navigationBarItems(leading: Button(action: {
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
                self.isDrawerOpen.toggle()
            }
        }) {
            Image(systemName: "sidebar.left")
        })
}