Learn Swift - 41 Code Examples & CST Typing Practice Test

Swift is a powerful, general-purpose, compiled programming language developed by Apple for iOS, macOS, watchOS, tvOS, and Linux. It emphasizes safety, performance, and modern programming practices.

View all 41 Swift code examples →

Learn SWIFT with Real Code Examples

Updated Nov 21, 2025

Explain

Swift allows developers to write fast, safe, and expressive code.

It uses type inference and optionals to minimize common programming errors.

Supports protocol-oriented, object-oriented, and functional programming paradigms.

Core Features

Memory safety and automatic reference counting (ARC)

Error handling with try/catch

Functional programming constructs (map, filter, reduce)

Powerful standard library

Interoperability with Objective-C

Basic Concepts Overview

Variables and constants: var and let

Data types: Int, Double, String, Bool, Array, Dictionary

Functions: named, closures, and higher-order functions

Control flow: if, switch, for, while, guard

Optionals: ? and ! for safe handling of nil values

Project Structure

AppDelegate.swift / SceneDelegate.swift - application lifecycle

ContentView.swift - SwiftUI main view

Models/ - data structures

Views/ - reusable UI components

Resources/ - assets, images, and storyboards

Building Workflow

Create a project in Xcode

Design UI using SwiftUI or Interface Builder

Write code in Swift files

Use simulators or physical devices to test

Debug using Xcode debugger and instruments

Difficulty Use Cases

Beginner: console programs and basic apps

Intermediate: SwiftUI views and state management

Advanced: complex apps with protocols and generics

Expert: concurrency, Combine, and performance optimization

Community: contributing to Swift packages or open-source frameworks

Comparisons

Faster and safer than Objective-C

More modern syntax and features than C/Obj-C

Optimized for Apple ecosystem

Optionals prevent null-pointer exceptions

Supports both object-oriented and functional paradigms

Versioning Timeline

2014 - Swift 1.0 released

2015 - Swift 2.0 with error handling and protocol extensions

2016 - Swift 3.0 major API redesign

2017 - Swift 4.0 with Codable and improved String handling

2025 - Swift continues evolving with Swift 6+ features

Glossary

Optional: type that can hold a value or nil

Struct: value type data container

Class: reference type object

Protocol: defines a blueprint of methods/properties

Closure: anonymous function or lambda

Code Sample Descriptions

Swift Concentric Circles

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for r in stride(from: 20.0, through: 180.0, by: 20.0) {
                let rect = CGRect(x: center.x-r, y: center.y-r, width: r*2, height: r*2)
                context.stroke(Path(ellipseIn: rect), with: .color(Color(hue: r/200, saturation: 1, brightness: 1)), lineWidth: 4)
            }
        }
    }
}

Draws colorful concentric circles using SwiftUI Canvas.

Let’s Try →

Swift Rainbow Spiral

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            var path = Path()
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for i in 0..<720 {
                let angle = Double(i) * 0.1
                let radius = Double(i) * 0.3
                let x = center.x + CGFloat(cos(angle) * radius)
                let y = center.y + CGFloat(sin(angle) * radius)
                i == 0 ? path.move(to: CGPoint(x: x, y: y)) : path.addLine(to: CGPoint(x: x, y: y))
            }
            context.stroke(path, with: .color(.red), lineWidth: 3)
        }
    }
}

Creates a colorful spiral using SwiftUI Canvas.

Let’s Try →

Swift Geometric Grid Patterns

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for x in stride(from: 0.0, to: size.width, by: 40) {
                for y in stride(from: 0.0, to: size.height, by: 40) {
                    context.stroke(Path(CGRect(x: x, y: y, width: 40, height: 40)), with: .color(.blue))
                }
            }
        }
    }
}

Draws a geometric square grid using SwiftUI Canvas.

Let’s Try →

Swift Checkerboard Variations

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let cell: CGFloat = 40
            for row in 0..<8 {
                for col in 0..<8 {
                    let color = (row + col).isMultiple(of: 2) ? Color.orange : Color.purple
                    context.fill(Path(CGRect(x: CGFloat(col)*cell, y: CGFloat(row)*cell, width: cell, height: cell)), with: .color(color))
                }
            }
        }
    }
}

Generates a colorful checkerboard pattern.

Let’s Try →

Swift Random Colored Dots

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for _ in 0..<300 {
                let x = CGFloat.random(in: 0...size.width)
                let y = CGFloat.random(in: 0...size.height)
                let rect = CGRect(x: x, y: y, width: 6, height: 6)
                context.fill(Path(ellipseIn: rect), with: .color(Color(hue: .random(in: 0...1), saturation: 1, brightness: 1)))
            }
        }
    }
}

Scatters random colored dots across the canvas.

Let’s Try →

Swift Abstract Rectangles

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for _ in 0..<100 {
                let rect = CGRect(x: .random(in: 0...size.width), y: .random(in: 0...size.height), width: .random(in: 20...100), height: .random(in: 20...100))
                context.fill(Path(rect), with: .color(Color(hue: .random(in: 0...1), saturation: 1, brightness: 1)))
            }
        }
    }
}

Draws randomly positioned colorful rectangles.

Let’s Try →

Swift Hexagon Tessellation

import SwiftUI

struct ContentView: View {
    func hexagon(at center: CGPoint, radius: CGFloat) -> Path {
        var path = Path()
        for i in 0..<6 {
            let angle = Double(i) * .pi / 3
            let point = CGPoint(x: center.x + cos(angle) * radius, y: center.y + sin(angle) * radius)
            i == 0 ? path.move(to: point) : path.addLine(to: point)
        }
        path.closeSubpath()
        return path
    }

    var body: some View {
        Canvas { context, size in
            for x in stride(from: 30.0, to: size.width, by: 60) {
                for y in stride(from: 30.0, to: size.height, by: 52) {
                    context.stroke(hexagon(at: CGPoint(x: x, y: y), radius: 25), with: .color(.green))
                }
            }
        }
    }
}

Creates a repeating hexagon tessellation pattern.

Let’s Try →

Swift Triangular Mosaic

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for x in stride(from: 0.0, to: size.width, by: 40) {
                for y in stride(from: 0.0, to: size.height, by: 40) {
                    var path = Path()
                    path.move(to: CGPoint(x: x, y: y))
                    path.addLine(to: CGPoint(x: x+40, y: y))
                    path.addLine(to: CGPoint(x: x+20, y: y+40))
                    path.closeSubpath()
                    context.fill(path, with: .color(.cyan))
                }
            }
        }
    }
}

Draws a colorful triangular mosaic.

Let’s Try →

Swift Kaleidoscope Designs

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for i in 0..<36 {
                let angle = Double(i) * .pi / 18
                var path = Path()
                path.move(to: center)
                path.addLine(to: CGPoint(x: center.x + cos(angle)*150, y: center.y + sin(angle)*150))
                context.stroke(path, with: .color(.pink), lineWidth: 2)
            }
        }
    }
}

Creates a radial kaleidoscope design using repeated lines.

Let’s Try →

Swift Symmetrical Mandalas

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for i in 0..<24 {
                let angle = Double(i) * .pi / 12
                let x = center.x + cos(angle) * 80
                let y = center.y + sin(angle) * 80
                context.fill(Path(ellipseIn: CGRect(x: x-15, y: y-15, width: 30, height: 30)), with: .color(.purple))
            }
        }
    }
}

Draws a simple symmetrical mandala using repeated circles.

Let’s Try →

Swift Lissajous Curves

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            var path = Path()
            let cx = size.width/2
            let cy = size.height/2
            for i in stride(from: 0.0, through: Double.pi*2, by: 0.01) {
                let x = cx + CGFloat(sin(3*i) * 140)
                let y = cy + CGFloat(sin(4*i) * 140)
                i == 0 ? path.move(to: CGPoint(x: x, y: y)) : path.addLine(to: CGPoint(x: x, y: y))
            }
            context.stroke(path, with: .color(.blue), lineWidth: 2)
        }
    }
}

Draws animated-style Lissajous curves using sine functions in SwiftUI Canvas.

Let’s Try →

Swift Spirograph

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let R = 120.0
            let r = 45.0
            let d = 60.0
            let center = CGPoint(x: size.width/2, y: size.height/2)
            var path = Path()
            for t in stride(from: 0.0, through: 40*Double.pi, by: 0.02) {
                let x = (R-r)*cos(t)+d*cos((R-r)/r*t)
                let y = (R-r)*sin(t)-d*sin((R-r)/r*t)
                let p = CGPoint(x: center.x+CGFloat(x), y: center.y+CGFloat(y))
                t == 0 ? path.move(to: p) : path.addLine(to: p)
            }
            context.stroke(path, with: .color(.red), lineWidth: 2)
        }
    }
}

Creates a spirograph using hypotrochoid equations.

Let’s Try →

Swift Rose Curves

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            var path = Path()
            for t in stride(from: 0.0, through: Double.pi*8, by: 0.01) {
                let r = 150*cos(5*t)
                let x = center.x + CGFloat(r*cos(t))
                let y = center.y + CGFloat(r*sin(t))
                t == 0 ? path.move(to: CGPoint(x:x,y:y)) : path.addLine(to: CGPoint(x:x,y:y))
            }
            context.stroke(path, with: .color(.pink), lineWidth: 2)
        }
    }
}

Draws a mathematical rose curve with polar equations.

Let’s Try →

Swift Polar Flower Equations

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let c = CGPoint(x: size.width/2, y: size.height/2)
            var path = Path()
            for t in stride(from:0.0,through:Double.pi*6,by:0.01){
                let r = 120*sin(6*t)
                let x = c.x + CGFloat(r*cos(t))
                let y = c.y + CGFloat(r*sin(t))
                t==0 ? path.move(to:CGPoint(x:x,y:y)) : path.addLine(to:CGPoint(x:x,y:y))
            }
            context.stroke(path, with:.color(.purple), lineWidth:2)
        }
    }
}

Generates a flower pattern using polar equations.

Let’s Try →

Swift Fibonacci Spiral

import SwiftUI

struct ContentView: View {
    let nums=[20,20,40,60,100,160,260]
    var body: some View {
        Canvas { context,size in
            var x:CGFloat=150
            var y:CGFloat=150
            for n in nums{
                let rect=CGRect(x:x,y:y,width:CGFloat(n),height:CGFloat(n))
                context.stroke(Path(ellipseIn:rect),with:.color(.orange))
                x+=10;y+=10
            }
        }
    }
}

Approximates a Fibonacci spiral using quarter-circle arcs.

Let’s Try →

Swift Golden Ratio Patterns

import SwiftUI

struct ContentView: View {
    let phi=1.618
    var body: some View {
        Canvas { context,size in
            var w:CGFloat=40
            var x:CGFloat=20
            for _ in 0..<8{
                let h=w*CGFloat(phi)
                context.stroke(Path(CGRect(x:x,y:40,width:w,height:h)),with:.color(.green))
                x+=w+10
                w*=0.8
            }
        }
    }
}

Visualizes rectangles based on the golden ratio.

Let’s Try →

Swift Harmonic Wave Interference

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var path=Path()
            for x in stride(from:0.0,to:size.width,by:1){
                let y=size.height/2+CGFloat(sin(x*0.05)*40+sin(x*0.08)*40)
                x==0 ? path.move(to:CGPoint(x:x,y:y)) : path.addLine(to:CGPoint(x:x,y:y))
            }
            context.stroke(path,with:.color(.cyan),lineWidth:2)
        }
    }
}

Draws the interference of two sine waves.

Let’s Try →

Swift Moiré Patterns

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for i in stride(from:0.0,to:size.width,by:8){
                context.stroke(Path{p in p.move(to:CGPoint(x:i,y:0));p.addLine(to:CGPoint(x:i+20,y:size.height))},with:.color(.black))
            }
        }
    }
}

Creates a moiré effect by overlapping line grids.

Let’s Try →

Swift Parametric Curves

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            let c=CGPoint(x:size.width/2,y:size.height/2)
            var path=Path()
            for t in stride(from:0.0,through:20.0,by:0.02){
                let x=c.x+CGFloat(120*cos(t))
                let y=c.y+CGFloat(80*sin(2*t))
                t==0 ? path.move(to:CGPoint(x:x,y:y)) : path.addLine(to:CGPoint(x:x,y:y))
            }
            context.stroke(path,with:.color(.indigo),lineWidth:2)
        }
    }
}

Draws a parametric curve using trigonometric equations.

Let’s Try →

Swift Penrose-Inspired Tilings

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for x in stride(from:40.0,to:size.width,by:60){
                for y in stride(from:40.0,to:size.height,by:60){
                    var p=Path()
                    p.move(to:CGPoint(x:x,y:y-20))
                    p.addLine(to:CGPoint(x:x+20,y:y))
                    p.addLine(to:CGPoint(x:x,y:y+20))
                    p.addLine(to:CGPoint(x:x-20,y:y))
                    p.closeSubpath()
                    context.stroke(p,with:.color(.brown))
                }
            }
        }
    }
}

Draws a simple Penrose-inspired tiling using repeated diamond shapes.

Let’s Try →

Swift Fractal Tree

import SwiftUI

struct ContentView: View {
    func branch(_ path: inout Path,_ p: CGPoint,_ len: CGFloat,_ angle: Double,_ depth: Int){
        guard depth > 0 else { return }
        let end = CGPoint(x: p.x + cos(angle) * len, y: p.y - sin(angle) * len)
        path.move(to: p)
        path.addLine(to: end)
        branch(&path,end,len*0.7,angle+0.4,depth-1)
        branch(&path,end,len*0.7,angle-0.4,depth-1)
    }
    var body: some View {
        Canvas { context,size in
            var path = Path()
            branch(&path,CGPoint(x:size.width/2,y:size.height-20),100,.pi/2,8)
            context.stroke(path,with:.color(.green),lineWidth:2)
        }
    }
}

Draws a recursive fractal tree using SwiftUI Canvas.

Let’s Try →

Swift Barnsley Fern

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var x = 0.0
            var y = 0.0
            for _ in 0..<50000 {
                let r = Double.random(in:0...1)
                let nx: Double
                let ny: Double
                switch r {
                case 0..<0.01: nx = 0; ny = 0.16*y
                case 0..<0.86: nx = 0.85*x+0.04*y; ny = -0.04*x+0.85*y+1.6
                case 0..<0.93: nx = 0.2*x-0.26*y; ny = 0.23*x+0.22*y+1.6
                default: nx = -0.15*x+0.28*y; ny = 0.26*x+0.24*y+0.44
                }
                x = nx; y = ny
                let p = CGRect(x: size.width/2+CGFloat(x*45), y: size.height-CGFloat(y*45), width: 1, height: 1)
                context.fill(Path(p), with:.color(.green))
            }
        }
    }
}

Generates the Barnsley fern fractal using affine transformations.

Let’s Try →

Swift Snowflake Generator

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            let c = CGPoint(x:size.width/2,y:size.height/2)
            for i in 0..<12 {
                let a = Double(i)*.pi/6
                var p = Path()
                p.move(to:c)
                p.addLine(to:CGPoint(x:c.x+cos(a)*120,y:c.y+sin(a)*120))
                context.stroke(p,with:.color(.cyan),lineWidth:2)
            }
        }
    }
}

Creates a simple radial snowflake design.

Let’s Try →

Swift Growing Vines and Branches

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var path = Path()
            var p = CGPoint(x:size.width/2,y:size.height)
            path.move(to:p)
            for i in 0..<150 {
                p.x += CGFloat.random(in:-8...8)
                p.y -= 4
                path.addLine(to:p)
            }
            context.stroke(path,with:.color(.green),lineWidth:2)
        }
    }
}

Simulates organically growing vine-like branches.

Let’s Try →

Swift Sunflower Seed Pattern

import SwiftUI

struct ContentView: View {
    let golden = Double.pi*(3-sqrt(5.0))
    var body: some View {
        Canvas { context,size in
            let c = CGPoint(x:size.width/2,y:size.height/2)
            for i in 0..<800 {
                let r = sqrt(Double(i))*5
                let a = Double(i)*golden
                let x = c.x + CGFloat(cos(a)*r)
                let y = c.y + CGFloat(sin(a)*r)
                context.fill(Path(ellipseIn:CGRect(x:x,y:y,width:4,height:4)),with:.color(.yellow))
            }
        }
    }
}

Draws a phyllotaxis sunflower seed arrangement.

Let’s Try →

Swift Leaf Venation Patterns

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var path = Path()
            path.move(to:CGPoint(x:size.width/2,y:50))
            path.addLine(to:CGPoint(x:size.width/2,y:350))
            for i in stride(from:70,to:340,by:20){
                path.move(to:CGPoint(x:size.width/2,y:i))
                path.addLine(to:CGPoint(x:size.width/2-50,y:i-10))
                path.move(to:CGPoint(x:size.width/2,y:i))
                path.addLine(to:CGPoint(x:size.width/2+50,y:i-10))
            }
            context.stroke(path,with:.color(.green),lineWidth:2)
        }
    }
}

Draws a stylized leaf with vein patterns.

Let’s Try →

Swift Particle System

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for _ in 0..<300 {
                let x = CGFloat.random(in:0...size.width)
                let y = CGFloat.random(in:0...size.height)
                context.fill(Path(ellipseIn:CGRect(x:x,y:y,width:3,height:3)),with:.color(.white))
            }
            }
    }
}

Creates a basic particle system with randomly positioned particles.

Let’s Try →

Swift Fireworks Simulation

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            let c = CGPoint(x:size.width/2,y:size.height/2)
            for i in 0..<200 {
                let a = Double(i)*.pi/100
                let r = CGFloat.random(in:40...150)
                let x = c.x + cos(a)*r
                let y = c.y + sin(a)*r
                context.fill(Path(ellipseIn:CGRect(x:x,y:y,width:4,height:4)),with:.color(.red))
            }
        }
    }
}

Draws a radial fireworks burst using colored particles.

Let’s Try →

Swift Boids Simulation

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for _ in 0..<80 {
                let x = CGFloat.random(in:0...size.width)
                let y = CGFloat.random(in:0...size.height)
                var p = Path()
                p.move(to:CGPoint(x:x,y:y))
                p.addLine(to:CGPoint(x:x+8,y:y+4))
                p.addLine(to:CGPoint(x:x,y:y+8))
                p.closeSubpath()
                context.fill(p,with:.color(.blue))
            }
        }
    }
}

Displays randomly placed boids as a starting flock simulation.

Let’s Try →

Swift Conway's Game of Life

import SwiftUI

struct ContentView: View {
    let rows = 25
    let cols = 25
    var body: some View {
        Canvas { context,size in
            let cell = size.width/CGFloat(cols)
            for r in 0..<rows {
                for c in 0..<cols {
                    if Bool.random() {
                        context.fill(Path(CGRect(x:CGFloat(c)*cell,y:CGFloat(r)*cell,width:cell-1,height:cell-1)),with:.color(.green))
                    }
                }
            }
        }
    }
}

Displays a random grid representing the initial state of Conway's Game of Life.

Let’s Try →

Swift Optionals and Closures

import Foundation

struct Person {
    let name: String
    let age: Int
    var email: String?
}

struct PersonManager {
    private var people: [Person] = []

    mutating func add(_ person: Person) {
        people.append(person)
    }

    func people(matching predicate: (Person) -> Bool) -> [Person] {
        people.filter(predicate)
    }

    mutating func updateEmail(for name: String, to newEmail: String) -> Bool {
        guard let index = people.firstIndex(where: { $0.name == name }) else {
            return false
        }

        var person = people[index]
        person.email = newEmail
        people[index] = person
        return true
    }
}

var manager = PersonManager()

manager.add(Person(name: "Alice", age: 25, email: "alice@example.com"))
manager.add(Person(name: "Bob", age: 30, email: nil))
manager.add(Person(name: "Charlie", age: 35, email: "charlie@example.com"))

manager.updateEmail(for: "Bob", to: "bob@example.com")

let adults = manager.people { $0.age >= 30 }

for person in adults {
    let email = person.email ?? "No email"
    print("\(person.name): \(email)")
}

Demonstrates Swift optionals, closures, structs, and collection filtering following Apple's Swift coding style.

Let’s Try →

Swift Counter

import Foundation

struct Counter {
    private(set) var count = 0

    mutating func increment() {
        count += 1
        showCount()
    }

    mutating func decrement() {
        count -= 1
        showCount()
    }

    func showCount() {
        print("Counter: \(count)")
    }
}

var counter = Counter()
counter.showCount()
counter.increment()
counter.increment()
counter.decrement()

Implements a reusable counter using a Swift struct and mutating methods.

Let’s Try →

Swift Theme Toggle

import Foundation

struct ThemeManager {
    private(set) var isDarkMode = false

    mutating func toggleTheme() {
        isDarkMode.toggle()
        showTheme()
    }

    func showTheme() {
        let theme = isDarkMode ? "Dark" : "Light"
        print("Theme: \(theme)")
    }
}

var themeManager = ThemeManager()
themeManager.showTheme()
themeManager.toggleTheme()
themeManager.toggleTheme()

Demonstrates a simple theme manager using Swift structs and methods.

Let’s Try →

Swift Score Tracker

import Foundation

struct ScoreTracker {
    private(set) var score = 0

    mutating func increase(by points: Int) {
        score += points
        showScore()
    }

    mutating func decrease(by points: Int) {
        score -= points
        showScore()
    }

    mutating func reset() {
        score = 0
        showScore()
    }

    func showScore() {
        print("Score: \(score)")
    }
}

var tracker = ScoreTracker()
tracker.showScore()
tracker.increase(by: 10)
tracker.decrease(by: 5)
tracker.reset()

Tracks a player's score using encapsulated Swift methods.

Let’s Try →

Swift Optional Binding Example

import Foundation

let names: [String?] = ["Alice", nil, "Charlie", "David", nil]

func greet(_ name: String?) {
    guard let name else {
        print("Name not provided")
        return
    }

    print("Hello, \(name)")
}

for name in names {
    greet(name)
}

Shows how to safely unwrap optional values using guard and optional binding.

Let’s Try →

Swift Health Tracker

import Foundation

struct HealthTracker {
    private(set) var health = 100

    mutating func takeDamage(_ amount: Int) {
        health = max(health - amount, 0)
        showHealth()
    }

    mutating func heal(_ amount: Int) {
        health = min(health + amount, 100)
        showHealth()
    }

    func showHealth() {
        print("Health: \(health)")
    }
}

var tracker = HealthTracker()
tracker.showHealth()
tracker.takeDamage(20)
tracker.heal(10)

Tracks player health using a Swift struct with encapsulated methods.

Let’s Try →

Swift Level Tracker

import Foundation

struct LevelTracker {
    private(set) var level = 1

    mutating func advance() {
        level += 1
        showLevel()
    }

    mutating func reset() {
        level = 1
        showLevel()
    }

    func showLevel() {
        print("Level: \(level)")
    }
}

var tracker = LevelTracker()
tracker.showLevel()
tracker.advance()
tracker.advance()
tracker.reset()

Manages player levels using Swift methods and encapsulated state.

Let’s Try →

Swift Coin Counter

import Foundation

struct CoinCounter {
    private(set) var coins = 0

    mutating func collect() {
        coins += 1
        showCoins()
    }

    mutating func spend() {
        guard coins > 0 else {
            print("No coins available")
            return
        }
        coins -= 1
        showCoins()
    }

    func showCoins() {
        print("Coins: \(coins)")
    }
}

var counter = CoinCounter()
counter.showCoins()
counter.collect()
counter.collect()
counter.spend()

Keeps track of collected coins using Swift structs and methods.

Let’s Try →

Swift Ammo Tracker

import Foundation

struct AmmoTracker {
    private let maximumAmmo = 10
    private(set) var ammo = 10

    mutating func shoot() {
        guard ammo > 0 else {
            print("Out of ammo")
            return
        }
        ammo -= 1
        showAmmo()
    }

    mutating func reload() {
        ammo = maximumAmmo
        showAmmo()
    }

    func showAmmo() {
        print("Ammo: \(ammo)")
    }
}

var tracker = AmmoTracker()
tracker.showAmmo()
tracker.shoot()
tracker.shoot()
tracker.reload()

Tracks ammunition with shooting and reloading actions following Swift conventions.

Let’s Try →

Swift Star Collector

import Foundation

struct StarCollector {
    private(set) var stars = 0

    mutating func collect() {
        stars += 1
        showStars()
    }

    mutating func remove() {
        guard stars > 0 else {
            print("No stars available")
            return
        }
        stars -= 1
        showStars()
    }

    func showStars() {
        print("Stars: \(stars)")
    }
}

var collector = StarCollector()
collector.showStars()
collector.collect()
collector.collect()
collector.remove()

Tracks collected stars using encapsulated Swift state and methods.

Let’s Try →

Swift Power-Up Timer

import Foundation

struct PowerUpTimer {
    private let maximumTime = 10
    private(set) var remainingTime = 10

    mutating func tick() {
        guard remainingTime > 0 else {
            print("Power-up expired")
            return
        }
        remainingTime -= 1
        showTime()
    }

    mutating func reset() {
        remainingTime = maximumTime
        showTime()
    }

    func showTime() {
        print("Power-Up Time: \(remainingTime)")
    }
}

var timer = PowerUpTimer()
timer.showTime()
timer.tick()
timer.tick()
timer.reset()

Simulates a simple power-up timer with countdown and reset functionality.

Let’s Try →

Frequently Asked Questions about Swift

What is Swift?

Swift is a powerful, general-purpose, compiled programming language developed by Apple for iOS, macOS, watchOS, tvOS, and Linux. It emphasizes safety, performance, and modern programming practices.

What are the primary use cases for Swift?

iOS app development. macOS desktop applications. watchOS and tvOS apps. Server-side applications using Swift on Linux. Cross-platform development with SwiftUI or server frameworks

What are the strengths of Swift?

Fast and efficient compiled language. Safe programming with fewer runtime crashes. Strong Apple ecosystem support. Modern and readable syntax. Active community and evolving language features

What are the limitations of Swift?

Primarily focused on Apple platforms. Limited third-party libraries compared to older languages. Requires Xcode for full IDE support. Smaller server-side ecosystem than Node.js or Java. Frequent updates may require code adjustments

How can I practice Swift typing speed?

CodeSpeedTest offers 41+ real Swift code examples for typing practice. You can measure your WPM, track accuracy, and improve your coding speed with guided exercises.

Learn Other Programming Languages

C React Python C++Rust TypeScript Kotlin PHP Java C#Ruby Mql Cql N1ql Cypher Gremlin Partiql Haskell Elixir Fsharp View all languages →

Learn Swift - 41 Code Examples & CST Typing Practice Test

Swift is a powerful, general-purpose, compiled programming language developed by Apple for iOS, macOS, watchOS, tvOS, and Linux. It emphasizes safety, performance, and modern programming practices.

View all 41 Swift code examples →

Learn SWIFT with Real Code Examples

Updated Nov 21, 2025

Explain

Swift allows developers to write fast, safe, and expressive code.

It uses type inference and optionals to minimize common programming errors.

Supports protocol-oriented, object-oriented, and functional programming paradigms.

Core Features

Memory safety and automatic reference counting (ARC)

Error handling with try/catch

Functional programming constructs (map, filter, reduce)

Powerful standard library

Interoperability with Objective-C

Basic Concepts Overview

Variables and constants: var and let

Data types: Int, Double, String, Bool, Array, Dictionary

Functions: named, closures, and higher-order functions

Control flow: if, switch, for, while, guard

Optionals: ? and ! for safe handling of nil values

Project Structure

AppDelegate.swift / SceneDelegate.swift - application lifecycle

ContentView.swift - SwiftUI main view

Models/ - data structures

Views/ - reusable UI components

Resources/ - assets, images, and storyboards

Building Workflow

Create a project in Xcode

Design UI using SwiftUI or Interface Builder

Write code in Swift files

Use simulators or physical devices to test

Debug using Xcode debugger and instruments

Difficulty Use Cases

Beginner: console programs and basic apps

Intermediate: SwiftUI views and state management

Advanced: complex apps with protocols and generics

Expert: concurrency, Combine, and performance optimization

Community: contributing to Swift packages or open-source frameworks

Comparisons

Faster and safer than Objective-C

More modern syntax and features than C/Obj-C

Optimized for Apple ecosystem

Optionals prevent null-pointer exceptions

Supports both object-oriented and functional paradigms

Versioning Timeline

2014 - Swift 1.0 released

2015 - Swift 2.0 with error handling and protocol extensions

2016 - Swift 3.0 major API redesign

2017 - Swift 4.0 with Codable and improved String handling

2025 - Swift continues evolving with Swift 6+ features

Glossary

Optional: type that can hold a value or nil

Struct: value type data container

Class: reference type object

Protocol: defines a blueprint of methods/properties

Closure: anonymous function or lambda

Code Sample Descriptions

Swift Concentric Circles

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for r in stride(from: 20.0, through: 180.0, by: 20.0) {
                let rect = CGRect(x: center.x-r, y: center.y-r, width: r*2, height: r*2)
                context.stroke(Path(ellipseIn: rect), with: .color(Color(hue: r/200, saturation: 1, brightness: 1)), lineWidth: 4)
            }
        }
    }
}

Draws colorful concentric circles using SwiftUI Canvas.

Let’s Try →

Swift Rainbow Spiral

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            var path = Path()
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for i in 0..<720 {
                let angle = Double(i) * 0.1
                let radius = Double(i) * 0.3
                let x = center.x + CGFloat(cos(angle) * radius)
                let y = center.y + CGFloat(sin(angle) * radius)
                i == 0 ? path.move(to: CGPoint(x: x, y: y)) : path.addLine(to: CGPoint(x: x, y: y))
            }
            context.stroke(path, with: .color(.red), lineWidth: 3)
        }
    }
}

Creates a colorful spiral using SwiftUI Canvas.

Let’s Try →

Swift Geometric Grid Patterns

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for x in stride(from: 0.0, to: size.width, by: 40) {
                for y in stride(from: 0.0, to: size.height, by: 40) {
                    context.stroke(Path(CGRect(x: x, y: y, width: 40, height: 40)), with: .color(.blue))
                }
            }
        }
    }
}

Draws a geometric square grid using SwiftUI Canvas.

Let’s Try →

Swift Checkerboard Variations

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let cell: CGFloat = 40
            for row in 0..<8 {
                for col in 0..<8 {
                    let color = (row + col).isMultiple(of: 2) ? Color.orange : Color.purple
                    context.fill(Path(CGRect(x: CGFloat(col)*cell, y: CGFloat(row)*cell, width: cell, height: cell)), with: .color(color))
                }
            }
        }
    }
}

Generates a colorful checkerboard pattern.

Let’s Try →

Swift Random Colored Dots

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for _ in 0..<300 {
                let x = CGFloat.random(in: 0...size.width)
                let y = CGFloat.random(in: 0...size.height)
                let rect = CGRect(x: x, y: y, width: 6, height: 6)
                context.fill(Path(ellipseIn: rect), with: .color(Color(hue: .random(in: 0...1), saturation: 1, brightness: 1)))
            }
        }
    }
}

Scatters random colored dots across the canvas.

Let’s Try →

Swift Abstract Rectangles

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for _ in 0..<100 {
                let rect = CGRect(x: .random(in: 0...size.width), y: .random(in: 0...size.height), width: .random(in: 20...100), height: .random(in: 20...100))
                context.fill(Path(rect), with: .color(Color(hue: .random(in: 0...1), saturation: 1, brightness: 1)))
            }
        }
    }
}

Draws randomly positioned colorful rectangles.

Let’s Try →

Swift Hexagon Tessellation

import SwiftUI

struct ContentView: View {
    func hexagon(at center: CGPoint, radius: CGFloat) -> Path {
        var path = Path()
        for i in 0..<6 {
            let angle = Double(i) * .pi / 3
            let point = CGPoint(x: center.x + cos(angle) * radius, y: center.y + sin(angle) * radius)
            i == 0 ? path.move(to: point) : path.addLine(to: point)
        }
        path.closeSubpath()
        return path
    }

    var body: some View {
        Canvas { context, size in
            for x in stride(from: 30.0, to: size.width, by: 60) {
                for y in stride(from: 30.0, to: size.height, by: 52) {
                    context.stroke(hexagon(at: CGPoint(x: x, y: y), radius: 25), with: .color(.green))
                }
            }
        }
    }
}

Creates a repeating hexagon tessellation pattern.

Let’s Try →

Swift Triangular Mosaic

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            for x in stride(from: 0.0, to: size.width, by: 40) {
                for y in stride(from: 0.0, to: size.height, by: 40) {
                    var path = Path()
                    path.move(to: CGPoint(x: x, y: y))
                    path.addLine(to: CGPoint(x: x+40, y: y))
                    path.addLine(to: CGPoint(x: x+20, y: y+40))
                    path.closeSubpath()
                    context.fill(path, with: .color(.cyan))
                }
            }
        }
    }
}

Draws a colorful triangular mosaic.

Let’s Try →

Swift Kaleidoscope Designs

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for i in 0..<36 {
                let angle = Double(i) * .pi / 18
                var path = Path()
                path.move(to: center)
                path.addLine(to: CGPoint(x: center.x + cos(angle)*150, y: center.y + sin(angle)*150))
                context.stroke(path, with: .color(.pink), lineWidth: 2)
            }
        }
    }
}

Creates a radial kaleidoscope design using repeated lines.

Let’s Try →

Swift Symmetrical Mandalas

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            for i in 0..<24 {
                let angle = Double(i) * .pi / 12
                let x = center.x + cos(angle) * 80
                let y = center.y + sin(angle) * 80
                context.fill(Path(ellipseIn: CGRect(x: x-15, y: y-15, width: 30, height: 30)), with: .color(.purple))
            }
        }
    }
}

Draws a simple symmetrical mandala using repeated circles.

Let’s Try →

Swift Lissajous Curves

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            var path = Path()
            let cx = size.width/2
            let cy = size.height/2
            for i in stride(from: 0.0, through: Double.pi*2, by: 0.01) {
                let x = cx + CGFloat(sin(3*i) * 140)
                let y = cy + CGFloat(sin(4*i) * 140)
                i == 0 ? path.move(to: CGPoint(x: x, y: y)) : path.addLine(to: CGPoint(x: x, y: y))
            }
            context.stroke(path, with: .color(.blue), lineWidth: 2)
        }
    }
}

Draws animated-style Lissajous curves using sine functions in SwiftUI Canvas.

Let’s Try →

Swift Spirograph

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let R = 120.0
            let r = 45.0
            let d = 60.0
            let center = CGPoint(x: size.width/2, y: size.height/2)
            var path = Path()
            for t in stride(from: 0.0, through: 40*Double.pi, by: 0.02) {
                let x = (R-r)*cos(t)+d*cos((R-r)/r*t)
                let y = (R-r)*sin(t)-d*sin((R-r)/r*t)
                let p = CGPoint(x: center.x+CGFloat(x), y: center.y+CGFloat(y))
                t == 0 ? path.move(to: p) : path.addLine(to: p)
            }
            context.stroke(path, with: .color(.red), lineWidth: 2)
        }
    }
}

Creates a spirograph using hypotrochoid equations.

Let’s Try →

Swift Rose Curves

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let center = CGPoint(x: size.width/2, y: size.height/2)
            var path = Path()
            for t in stride(from: 0.0, through: Double.pi*8, by: 0.01) {
                let r = 150*cos(5*t)
                let x = center.x + CGFloat(r*cos(t))
                let y = center.y + CGFloat(r*sin(t))
                t == 0 ? path.move(to: CGPoint(x:x,y:y)) : path.addLine(to: CGPoint(x:x,y:y))
            }
            context.stroke(path, with: .color(.pink), lineWidth: 2)
        }
    }
}

Draws a mathematical rose curve with polar equations.

Let’s Try →

Swift Polar Flower Equations

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context, size in
            let c = CGPoint(x: size.width/2, y: size.height/2)
            var path = Path()
            for t in stride(from:0.0,through:Double.pi*6,by:0.01){
                let r = 120*sin(6*t)
                let x = c.x + CGFloat(r*cos(t))
                let y = c.y + CGFloat(r*sin(t))
                t==0 ? path.move(to:CGPoint(x:x,y:y)) : path.addLine(to:CGPoint(x:x,y:y))
            }
            context.stroke(path, with:.color(.purple), lineWidth:2)
        }
    }
}

Generates a flower pattern using polar equations.

Let’s Try →

Swift Fibonacci Spiral

import SwiftUI

struct ContentView: View {
    let nums=[20,20,40,60,100,160,260]
    var body: some View {
        Canvas { context,size in
            var x:CGFloat=150
            var y:CGFloat=150
            for n in nums{
                let rect=CGRect(x:x,y:y,width:CGFloat(n),height:CGFloat(n))
                context.stroke(Path(ellipseIn:rect),with:.color(.orange))
                x+=10;y+=10
            }
        }
    }
}

Approximates a Fibonacci spiral using quarter-circle arcs.

Let’s Try →

Swift Golden Ratio Patterns

import SwiftUI

struct ContentView: View {
    let phi=1.618
    var body: some View {
        Canvas { context,size in
            var w:CGFloat=40
            var x:CGFloat=20
            for _ in 0..<8{
                let h=w*CGFloat(phi)
                context.stroke(Path(CGRect(x:x,y:40,width:w,height:h)),with:.color(.green))
                x+=w+10
                w*=0.8
            }
        }
    }
}

Visualizes rectangles based on the golden ratio.

Let’s Try →

Swift Harmonic Wave Interference

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var path=Path()
            for x in stride(from:0.0,to:size.width,by:1){
                let y=size.height/2+CGFloat(sin(x*0.05)*40+sin(x*0.08)*40)
                x==0 ? path.move(to:CGPoint(x:x,y:y)) : path.addLine(to:CGPoint(x:x,y:y))
            }
            context.stroke(path,with:.color(.cyan),lineWidth:2)
        }
    }
}

Draws the interference of two sine waves.

Let’s Try →

Swift Moiré Patterns

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for i in stride(from:0.0,to:size.width,by:8){
                context.stroke(Path{p in p.move(to:CGPoint(x:i,y:0));p.addLine(to:CGPoint(x:i+20,y:size.height))},with:.color(.black))
            }
        }
    }
}

Creates a moiré effect by overlapping line grids.

Let’s Try →

Swift Parametric Curves

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            let c=CGPoint(x:size.width/2,y:size.height/2)
            var path=Path()
            for t in stride(from:0.0,through:20.0,by:0.02){
                let x=c.x+CGFloat(120*cos(t))
                let y=c.y+CGFloat(80*sin(2*t))
                t==0 ? path.move(to:CGPoint(x:x,y:y)) : path.addLine(to:CGPoint(x:x,y:y))
            }
            context.stroke(path,with:.color(.indigo),lineWidth:2)
        }
    }
}

Draws a parametric curve using trigonometric equations.

Let’s Try →

Swift Penrose-Inspired Tilings

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for x in stride(from:40.0,to:size.width,by:60){
                for y in stride(from:40.0,to:size.height,by:60){
                    var p=Path()
                    p.move(to:CGPoint(x:x,y:y-20))
                    p.addLine(to:CGPoint(x:x+20,y:y))
                    p.addLine(to:CGPoint(x:x,y:y+20))
                    p.addLine(to:CGPoint(x:x-20,y:y))
                    p.closeSubpath()
                    context.stroke(p,with:.color(.brown))
                }
            }
        }
    }
}

Draws a simple Penrose-inspired tiling using repeated diamond shapes.

Let’s Try →

Swift Fractal Tree

import SwiftUI

struct ContentView: View {
    func branch(_ path: inout Path,_ p: CGPoint,_ len: CGFloat,_ angle: Double,_ depth: Int){
        guard depth > 0 else { return }
        let end = CGPoint(x: p.x + cos(angle) * len, y: p.y - sin(angle) * len)
        path.move(to: p)
        path.addLine(to: end)
        branch(&path,end,len*0.7,angle+0.4,depth-1)
        branch(&path,end,len*0.7,angle-0.4,depth-1)
    }
    var body: some View {
        Canvas { context,size in
            var path = Path()
            branch(&path,CGPoint(x:size.width/2,y:size.height-20),100,.pi/2,8)
            context.stroke(path,with:.color(.green),lineWidth:2)
        }
    }
}

Draws a recursive fractal tree using SwiftUI Canvas.

Let’s Try →

Swift Barnsley Fern

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var x = 0.0
            var y = 0.0
            for _ in 0..<50000 {
                let r = Double.random(in:0...1)
                let nx: Double
                let ny: Double
                switch r {
                case 0..<0.01: nx = 0; ny = 0.16*y
                case 0..<0.86: nx = 0.85*x+0.04*y; ny = -0.04*x+0.85*y+1.6
                case 0..<0.93: nx = 0.2*x-0.26*y; ny = 0.23*x+0.22*y+1.6
                default: nx = -0.15*x+0.28*y; ny = 0.26*x+0.24*y+0.44
                }
                x = nx; y = ny
                let p = CGRect(x: size.width/2+CGFloat(x*45), y: size.height-CGFloat(y*45), width: 1, height: 1)
                context.fill(Path(p), with:.color(.green))
            }
        }
    }
}

Generates the Barnsley fern fractal using affine transformations.

Let’s Try →

Swift Snowflake Generator

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            let c = CGPoint(x:size.width/2,y:size.height/2)
            for i in 0..<12 {
                let a = Double(i)*.pi/6
                var p = Path()
                p.move(to:c)
                p.addLine(to:CGPoint(x:c.x+cos(a)*120,y:c.y+sin(a)*120))
                context.stroke(p,with:.color(.cyan),lineWidth:2)
            }
        }
    }
}

Creates a simple radial snowflake design.

Let’s Try →

Swift Growing Vines and Branches

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var path = Path()
            var p = CGPoint(x:size.width/2,y:size.height)
            path.move(to:p)
            for i in 0..<150 {
                p.x += CGFloat.random(in:-8...8)
                p.y -= 4
                path.addLine(to:p)
            }
            context.stroke(path,with:.color(.green),lineWidth:2)
        }
    }
}

Simulates organically growing vine-like branches.

Let’s Try →

Swift Sunflower Seed Pattern

import SwiftUI

struct ContentView: View {
    let golden = Double.pi*(3-sqrt(5.0))
    var body: some View {
        Canvas { context,size in
            let c = CGPoint(x:size.width/2,y:size.height/2)
            for i in 0..<800 {
                let r = sqrt(Double(i))*5
                let a = Double(i)*golden
                let x = c.x + CGFloat(cos(a)*r)
                let y = c.y + CGFloat(sin(a)*r)
                context.fill(Path(ellipseIn:CGRect(x:x,y:y,width:4,height:4)),with:.color(.yellow))
            }
        }
    }
}

Draws a phyllotaxis sunflower seed arrangement.

Let’s Try →

Swift Leaf Venation Patterns

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            var path = Path()
            path.move(to:CGPoint(x:size.width/2,y:50))
            path.addLine(to:CGPoint(x:size.width/2,y:350))
            for i in stride(from:70,to:340,by:20){
                path.move(to:CGPoint(x:size.width/2,y:i))
                path.addLine(to:CGPoint(x:size.width/2-50,y:i-10))
                path.move(to:CGPoint(x:size.width/2,y:i))
                path.addLine(to:CGPoint(x:size.width/2+50,y:i-10))
            }
            context.stroke(path,with:.color(.green),lineWidth:2)
        }
    }
}

Draws a stylized leaf with vein patterns.

Let’s Try →

Swift Particle System

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for _ in 0..<300 {
                let x = CGFloat.random(in:0...size.width)
                let y = CGFloat.random(in:0...size.height)
                context.fill(Path(ellipseIn:CGRect(x:x,y:y,width:3,height:3)),with:.color(.white))
            }
            }
    }
}

Creates a basic particle system with randomly positioned particles.

Let’s Try →

Swift Fireworks Simulation

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            let c = CGPoint(x:size.width/2,y:size.height/2)
            for i in 0..<200 {
                let a = Double(i)*.pi/100
                let r = CGFloat.random(in:40...150)
                let x = c.x + cos(a)*r
                let y = c.y + sin(a)*r
                context.fill(Path(ellipseIn:CGRect(x:x,y:y,width:4,height:4)),with:.color(.red))
            }
        }
    }
}

Draws a radial fireworks burst using colored particles.

Let’s Try →

Swift Boids Simulation

import SwiftUI

struct ContentView: View {
    var body: some View {
        Canvas { context,size in
            for _ in 0..<80 {
                let x = CGFloat.random(in:0...size.width)
                let y = CGFloat.random(in:0...size.height)
                var p = Path()
                p.move(to:CGPoint(x:x,y:y))
                p.addLine(to:CGPoint(x:x+8,y:y+4))
                p.addLine(to:CGPoint(x:x,y:y+8))
                p.closeSubpath()
                context.fill(p,with:.color(.blue))
            }
        }
    }
}

Displays randomly placed boids as a starting flock simulation.

Let’s Try →

Swift Conway's Game of Life

import SwiftUI

struct ContentView: View {
    let rows = 25
    let cols = 25
    var body: some View {
        Canvas { context,size in
            let cell = size.width/CGFloat(cols)
            for r in 0..<rows {
                for c in 0..<cols {
                    if Bool.random() {
                        context.fill(Path(CGRect(x:CGFloat(c)*cell,y:CGFloat(r)*cell,width:cell-1,height:cell-1)),with:.color(.green))
                    }
                }
            }
        }
    }
}

Displays a random grid representing the initial state of Conway's Game of Life.

Let’s Try →

Swift Optionals and Closures

import Foundation

struct Person {
    let name: String
    let age: Int
    var email: String?
}

struct PersonManager {
    private var people: [Person] = []

    mutating func add(_ person: Person) {
        people.append(person)
    }

    func people(matching predicate: (Person) -> Bool) -> [Person] {
        people.filter(predicate)
    }

    mutating func updateEmail(for name: String, to newEmail: String) -> Bool {
        guard let index = people.firstIndex(where: { $0.name == name }) else {
            return false
        }

        var person = people[index]
        person.email = newEmail
        people[index] = person
        return true
    }
}

var manager = PersonManager()

manager.add(Person(name: "Alice", age: 25, email: "alice@example.com"))
manager.add(Person(name: "Bob", age: 30, email: nil))
manager.add(Person(name: "Charlie", age: 35, email: "charlie@example.com"))

manager.updateEmail(for: "Bob", to: "bob@example.com")

let adults = manager.people { $0.age >= 30 }

for person in adults {
    let email = person.email ?? "No email"
    print("\(person.name): \(email)")
}

Demonstrates Swift optionals, closures, structs, and collection filtering following Apple's Swift coding style.

Let’s Try →

Swift Counter

import Foundation

struct Counter {
    private(set) var count = 0

    mutating func increment() {
        count += 1
        showCount()
    }

    mutating func decrement() {
        count -= 1
        showCount()
    }

    func showCount() {
        print("Counter: \(count)")
    }
}

var counter = Counter()
counter.showCount()
counter.increment()
counter.increment()
counter.decrement()

Implements a reusable counter using a Swift struct and mutating methods.

Let’s Try →

Swift Theme Toggle

import Foundation

struct ThemeManager {
    private(set) var isDarkMode = false

    mutating func toggleTheme() {
        isDarkMode.toggle()
        showTheme()
    }

    func showTheme() {
        let theme = isDarkMode ? "Dark" : "Light"
        print("Theme: \(theme)")
    }
}

var themeManager = ThemeManager()
themeManager.showTheme()
themeManager.toggleTheme()
themeManager.toggleTheme()

Demonstrates a simple theme manager using Swift structs and methods.

Let’s Try →

Swift Score Tracker

import Foundation

struct ScoreTracker {
    private(set) var score = 0

    mutating func increase(by points: Int) {
        score += points
        showScore()
    }

    mutating func decrease(by points: Int) {
        score -= points
        showScore()
    }

    mutating func reset() {
        score = 0
        showScore()
    }

    func showScore() {
        print("Score: \(score)")
    }
}

var tracker = ScoreTracker()
tracker.showScore()
tracker.increase(by: 10)
tracker.decrease(by: 5)
tracker.reset()

Tracks a player's score using encapsulated Swift methods.

Let’s Try →

Swift Optional Binding Example

import Foundation

let names: [String?] = ["Alice", nil, "Charlie", "David", nil]

func greet(_ name: String?) {
    guard let name else {
        print("Name not provided")
        return
    }

    print("Hello, \(name)")
}

for name in names {
    greet(name)
}

Shows how to safely unwrap optional values using guard and optional binding.

Let’s Try →

Swift Health Tracker

import Foundation

struct HealthTracker {
    private(set) var health = 100

    mutating func takeDamage(_ amount: Int) {
        health = max(health - amount, 0)
        showHealth()
    }

    mutating func heal(_ amount: Int) {
        health = min(health + amount, 100)
        showHealth()
    }

    func showHealth() {
        print("Health: \(health)")
    }
}

var tracker = HealthTracker()
tracker.showHealth()
tracker.takeDamage(20)
tracker.heal(10)

Tracks player health using a Swift struct with encapsulated methods.

Let’s Try →

Swift Level Tracker

import Foundation

struct LevelTracker {
    private(set) var level = 1

    mutating func advance() {
        level += 1
        showLevel()
    }

    mutating func reset() {
        level = 1
        showLevel()
    }

    func showLevel() {
        print("Level: \(level)")
    }
}

var tracker = LevelTracker()
tracker.showLevel()
tracker.advance()
tracker.advance()
tracker.reset()

Manages player levels using Swift methods and encapsulated state.

Let’s Try →

Swift Coin Counter

import Foundation

struct CoinCounter {
    private(set) var coins = 0

    mutating func collect() {
        coins += 1
        showCoins()
    }

    mutating func spend() {
        guard coins > 0 else {
            print("No coins available")
            return
        }
        coins -= 1
        showCoins()
    }

    func showCoins() {
        print("Coins: \(coins)")
    }
}

var counter = CoinCounter()
counter.showCoins()
counter.collect()
counter.collect()
counter.spend()

Keeps track of collected coins using Swift structs and methods.

Let’s Try →

Swift Ammo Tracker

import Foundation

struct AmmoTracker {
    private let maximumAmmo = 10
    private(set) var ammo = 10

    mutating func shoot() {
        guard ammo > 0 else {
            print("Out of ammo")
            return
        }
        ammo -= 1
        showAmmo()
    }

    mutating func reload() {
        ammo = maximumAmmo
        showAmmo()
    }

    func showAmmo() {
        print("Ammo: \(ammo)")
    }
}

var tracker = AmmoTracker()
tracker.showAmmo()
tracker.shoot()
tracker.shoot()
tracker.reload()

Tracks ammunition with shooting and reloading actions following Swift conventions.

Let’s Try →

Swift Star Collector

import Foundation

struct StarCollector {
    private(set) var stars = 0

    mutating func collect() {
        stars += 1
        showStars()
    }

    mutating func remove() {
        guard stars > 0 else {
            print("No stars available")
            return
        }
        stars -= 1
        showStars()
    }

    func showStars() {
        print("Stars: \(stars)")
    }
}

var collector = StarCollector()
collector.showStars()
collector.collect()
collector.collect()
collector.remove()

Tracks collected stars using encapsulated Swift state and methods.

Let’s Try →

Swift Power-Up Timer

import Foundation

struct PowerUpTimer {
    private let maximumTime = 10
    private(set) var remainingTime = 10

    mutating func tick() {
        guard remainingTime > 0 else {
            print("Power-up expired")
            return
        }
        remainingTime -= 1
        showTime()
    }

    mutating func reset() {
        remainingTime = maximumTime
        showTime()
    }

    func showTime() {
        print("Power-Up Time: \(remainingTime)")
    }
}

var timer = PowerUpTimer()
timer.showTime()
timer.tick()
timer.tick()
timer.reset()

Simulates a simple power-up timer with countdown and reset functionality.

Let’s Try →

Frequently Asked Questions about Swift

What is Swift?

Swift is a powerful, general-purpose, compiled programming language developed by Apple for iOS, macOS, watchOS, tvOS, and Linux. It emphasizes safety, performance, and modern programming practices.

What are the primary use cases for Swift?

iOS app development. macOS desktop applications. watchOS and tvOS apps. Server-side applications using Swift on Linux. Cross-platform development with SwiftUI or server frameworks

What are the strengths of Swift?

Fast and efficient compiled language. Safe programming with fewer runtime crashes. Strong Apple ecosystem support. Modern and readable syntax. Active community and evolving language features

What are the limitations of Swift?

How can I practice Swift typing speed?

CodeSpeedTest offers 41+ real Swift code examples for typing practice. You can measure your WPM, track accuracy, and improve your coding speed with guided exercises.

Learn Other Programming Languages

C React Python C++Rust TypeScript Kotlin PHP Java C#Ruby Mql Cql N1ql Cypher Gremlin Partiql Haskell Elixir Fsharp View all languages →

Learn Swift - 41 Code Examples & CST Typing Practice Test

Learn SWIFT with Real Code Examples

Explain

Core Features

Basic Concepts Overview

Project Structure

Building Workflow

Difficulty Use Cases

Comparisons

Versioning Timeline

Glossary

Installation Setup

Environment Setup

Config Files

Cli Commands

Internationalization

Accessibility

Ui Styling

State Management

Data Management

Architecture

Rendering Model

Architectural Patterns

Real World Architectures

Design Principles

Scalability Guide

Migration Guide

Performance Notes

Security Notes

Monitoring Analytics

Code Quality

Practical Examples

Troubleshooting

Testing Guide

Deployment Options

Tools Ecosystem

Integrations

Productivity Tips

Challenges

Learning Path

Skill Improvement Plan

Interview Questions

Cheat Sheet

Books

Tutorials

Official Docs

Community Links

Community Support

Monetization

Future Roadmap

When Not To Use

Final Summary

Faq

Code Sample Descriptions

Swift Concentric Circles

Swift Rainbow Spiral

Swift Geometric Grid Patterns

Swift Checkerboard Variations

Swift Random Colored Dots

Swift Abstract Rectangles

Swift Hexagon Tessellation

Swift Triangular Mosaic

Swift Kaleidoscope Designs

Swift Symmetrical Mandalas

Swift Lissajous Curves

Swift Spirograph

Swift Rose Curves

Swift Polar Flower Equations

Swift Fibonacci Spiral

Swift Golden Ratio Patterns

Swift Harmonic Wave Interference

Swift Moiré Patterns

Swift Parametric Curves

Swift Penrose-Inspired Tilings

Swift Fractal Tree

Swift Barnsley Fern

Swift Snowflake Generator

Swift Growing Vines and Branches

Swift Sunflower Seed Pattern

Swift Leaf Venation Patterns