Learning Swift becomes much more interesting when you stop reading about programming and actually run your first program.

If you have already installed Swift and Xcode on your Mac, the next step is simple:

Write a small Swift program, run it, understand the output, make a few changes, and learn how Swift turns your code into a working program.

Your first program does not need to be an iPhone application.

In fact, starting with a simple command-line Swift program is one of the easiest ways to understand how Swift works without worrying about buttons, screens, navigation, or user interfaces.

In this complete beginner’s guide, you will learn:

• How to check whether Swift is ready
• How to write your first Swift program
• How to create a .swift file
• How to run Swift code from Terminal
• How to compile Swift code
• How to run the compiled executable
• How to use variables and constants
• How to print multiple values
• How to perform calculations
• How to use conditions
• How to create functions
• How to run Swift using Xcode
• How to create a basic SwiftUI app
• How to understand compiler errors
• How to fix common beginner problems

By the end of this guide, you will have written and executed several small Swift programs yourself.

---

Before You Run Your First Swift Program

Before writing code, make sure Swift is available on your computer.

If you are using macOS, open Terminal.

You can open Terminal using Spotlight:

Command + Space

Search for:

Terminal

Then press Enter.

Now run:

swift --version

If Swift is installed correctly, you should see information about your installed Swift version and target platform.

The exact version depends on your current development environment.

You can also check the Swift compiler:

swiftc --version

If both commands return version information, you are ready to start.

---

What Is a Swift Program?

A Swift program is simply a collection of instructions written using Swift syntax.

For example:

print("Hello, World!")

This tells Swift:

Display the text “Hello, World!” in the output.

When executed, the result is:

Hello, World!

This may look extremely simple, but it demonstrates the complete programming process:

Write Code
   ↓
Swift Processes the Code
   ↓
Program Executes
   ↓
Output Appears

Every application you eventually build follows the same fundamental idea, even though real applications contain thousands or millions of lines of code.

---

Your First Swift Program

The traditional first program in almost every programming language displays:

Hello, World!

In Swift, write:

print("Hello, World!")

That’s it.

Swift’s print() function displays information in the console.

The general syntax is:

print(value)

For text:

print("Hello Swift")

For a number:

print(100)

For a Boolean:

print(true)

---

Method 1: Run Your First Swift Program Using Terminal

One of the simplest ways to understand Swift is to create a .swift file and run it from Terminal.

Let’s do this step by step.

---

Step 1: Create a Folder for Swift Practice

Open Terminal.

Create a folder:

mkdir SwiftPractice

Move into the folder:

cd SwiftPractice

Check your current directory:

pwd

You should see a path ending with something similar to:

/SwiftPractice

---

Step 2: Create Your First Swift File

Create a file named:

hello.swift

Using Terminal:

touch hello.swift

Now list the files:

ls

You should see:

hello.swift

The .swift extension tells you that this is a Swift source-code file.

---

Step 3: Add Swift Code

Open the file in a text editor.

For example:

open -e hello.swift

Add:

print("Hello, World!")

Save the file.

Your complete program contains only one line:

print("Hello, World!")

---

Step 4: Run the Swift File

Return to Terminal.

Make sure you are still inside the directory containing:

hello.swift

Run:

swift hello.swift

You should see:

Hello, World!

Congratulations.

You have successfully run your first Swift program.

---

What Just Happened?

You created a source file:

hello.swift

The file contained:

print("Hello, World!")

Then you executed:

swift hello.swift

Swift processed the source code and executed it.

The process can be visualized like this:

hello.swift
    ↓
Swift
    ↓
Execute Program
    ↓
Hello, World!

This approach is convenient for:

• Learning Swift syntax
• Small scripts
• Testing ideas
• Practicing programming concepts

---

Method 2: Compile Your First Swift Program

Running:

swift hello.swift

is convenient while learning.

But Swift is also a compiled programming language.

You can compile your source code into an executable program using the Swift compiler.

The compiler command is:

swiftc

---

Step 1: Compile the Swift File

Run:

swiftc hello.swift

Now check the files:

ls

Along with:

hello.swift

you should have an executable generated by the compiler.

For this example, it may be named:

hello

---

Step 2: Run the Compiled Program

Run:

./hello

Output:

Hello, World!

You have now compiled and executed your Swift program.

---

Swift vs Swiftc

Beginners often confuse these two commands.

swift

You can use Swift’s command-line tooling to run a simple Swift script:

swift hello.swift

swiftc

swiftc is the Swift compiler.

Example:

swiftc hello.swift

It compiles your source code into an executable.

You then run:

./hello

A simplified comparison:

Command	Purpose
swift hello.swift	Run a Swift script
swiftc hello.swift	Compile Swift source
./hello	Run compiled executable

---

Give Your Executable a Custom Name

Instead of letting the compiler choose the default output name, specify one yourself.

Use:

swiftc hello.swift -o myprogram

Now:

ls

should show:

myprogram

Run:

./myprogram

Output:

Hello, World!

The option:

-o

means that you are specifying the output executable name.

For example:

swiftc main.swift -o calculator

would create an executable named:

calculator

---

Understanding print() in Swift

The first Swift function most beginners use is:

print()

It displays information.

Example:

print("Learning Swift")

Output:

Learning Swift

You can print multiple lines:

print("Hello")
print("Welcome to Swift")
print("Let's start programming!")

Output:

Hello
Welcome to Swift
Let's start programming!

---

Printing Numbers

You don’t need quotation marks around numeric values.

Example:

print(10)
print(20)
print(30)

Output:

10
20
30

If you write:

print("10")

then "10" is text.

If you write:

print(10)

then 10 is a numeric value.

That distinction becomes important when performing calculations.

---

Perform Your First Calculation

Let’s make your program more useful.

Replace your code with:

print(10 + 20)

Run:

swift hello.swift

Output:

30

Swift calculated the expression before printing it.

Try:

print(50 - 20)
print(10 * 5)
print(100 / 4)

Output:

30
50
25

Swift supports common arithmetic operators:

+   Addition
-   Subtraction
*   Multiplication
/   Division
%   Remainder

---

Create Your First Swift Variable

A variable stores information that can change.

Swift uses:

var

Example:

var name = "Alex"

print(name)

Output:

Alex

You can change the value:

var name = "Alex"

name = "John"

print(name)

Output:

John

---

Create Your First Swift Constant

Swift uses:

let

for constants.

Example:

let language = "Swift"

print(language)

Output:

Swift

A constant cannot be reassigned after it has been initialized.

For example:

let language = "Swift"

language = "Kotlin"

will produce a compiler error.

A simple rule for beginners is:

var → Value can change

let → Value should not change

---

Create a More Useful Program

Now combine variables and constants:

let name = "Alex"
var age = 20

print(name)
print(age)

Output:

Alex
20

Change:

age = 21

Complete example:

let name = "Alex"
var age = 20

age = 21

print(name)
print(age)

Output:

Alex
21

---

String Interpolation in Your First Program

Instead of printing values separately, you can insert them into text.

Swift uses:

\(value)

This is called string interpolation.

Example:

let name = "Alex"
let age = 25

print("My name is \(name).")
print("I am \(age) years old.")

Output:

My name is Alex.
I am 25 years old.

You can also include calculations:

let a = 10
let b = 20

print("Total: \(a + b)")

Output:

Total: 30

---

Build a Simple Introduction Program

Create:

intro.swift

Add:

let name = "Alex"
let age = 25
let language = "Swift"

print("Hello!")
print("My name is \(name).")
print("I am \(age) years old.")
print("I am learning \(language) programming.")

Run:

swift intro.swift

Output:

Hello!
My name is Alex.
I am 25 years old.
I am learning Swift programming.

This small program already demonstrates:

• Constants
• Strings
• Integers
• print()
• String interpolation

---

Your First If-Else Program

Programs become useful when they can make decisions.

Swift uses if statements.

Example:

let age = 20

if age >= 18 {
    print("You are an adult.")
}

Output:

You are an adult.

Add an else:

let age = 16

if age >= 18 {
    print("You are an adult.")
} else {
    print("You are a minor.")
}

Output:

You are a minor.

Now your program is making a decision based on data.

---

Your First Swift Loop

Loops repeat code.

Example:

for number in 1...5 {
    print(number)
}

Output:

1
2
3
4
5

Try:

for number in 1...5 {
    print("Swift lesson \(number)")
}

Output:

Swift lesson 1
Swift lesson 2
Swift lesson 3
Swift lesson 4
Swift lesson 5

---

Your First Swift Array

An array stores multiple values.

Example:

let languages = ["Swift", "Kotlin", "Dart"]

print(languages)

You can loop through them:

let languages = ["Swift", "Kotlin", "Dart"]

for language in languages {
    print(language)
}

Output:

Swift
Kotlin
Dart

This combines two important programming concepts:

Array + Loop

---

Your First Swift Function

Functions allow you to organize reusable code.

Example:

func greet() {
    print("Hello from Swift!")
}

greet()

Output:

Hello from Swift!

You can call it multiple times:

greet()
greet()
greet()

The same code runs each time.

---

Function with a Parameter

Let’s make the function more useful:

func greet(name: String) {
    print("Hello, \(name)!")
}

greet(name: "Alex")

Output:

Hello, Alex!

Call it with another value:

greet(name: "John")

Output:

Hello, John!

---

Function That Returns a Value

Functions can calculate and return results.

Example:

func add(a: Int, b: Int) -> Int {
    return a + b
}

Use it:

let result = add(a: 10, b: 20)

print(result)

Output:

30

Complete program:

func add(a: Int, b: Int) -> Int {
    return a + b
}

let result = add(a: 10, b: 20)

print("Result: \(result)")

Output:

Result: 30

---

Build Your First Mini Swift Program

Let’s combine several concepts.

Create:

student.swift

Add:

let studentName = "Alex"
let marks = 82

print("Student: \(studentName)")
print("Marks: \(marks)")

if marks >= 90 {
    print("Grade: A")
} else if marks >= 75 {
    print("Grade: B")
} else if marks >= 60 {
    print("Grade: C")
} else {
    print("Grade: D")
}

Run:

swift student.swift

Output:

Student: Alex
Marks: 82
Grade: B

You have now created a small program with:

• Constants
• Strings
• Integers
• Output
• Conditions
• Comparison operators

---

Create a Simple Calculator in Swift

Let’s build another beginner project.

Create:

calculator.swift

Add:

let firstNumber = 20
let secondNumber = 10

let addition = firstNumber + secondNumber
let subtraction = firstNumber - secondNumber
let multiplication = firstNumber * secondNumber
let division = firstNumber / secondNumber

print("First Number: \(firstNumber)")
print("Second Number: \(secondNumber)")

print("Addition: \(addition)")
print("Subtraction: \(subtraction)")
print("Multiplication: \(multiplication)")
print("Division: \(division)")

Run:

swift calculator.swift

Output:

First Number: 20
Second Number: 10
Addition: 30
Subtraction: 10
Multiplication: 200
Division: 2

This is a basic calculator program without interactive input.

---

Reading User Input in a Swift Command-Line Program

Now let’s make your program interactive.

Swift provides:

readLine()

to read a line of input from the console.

Example:

print("What is your name?")

let name = readLine()

print("Hello, \(name ?? "Guest")!")

Run:

swift hello.swift

Terminal will display:

What is your name?

Type:

Alex

Then press Enter.

Output:

Hello, Alex!

---

Why Does readLine() Return an Optional?

readLine() may fail to receive a value, so Swift returns an Optional String.

That is why this code uses:

name ?? "Guest"

The ?? operator provides a fallback value.

If name exists, Swift uses it.

Otherwise:

Guest

is used.

This is your first practical encounter with Swift Optionals.

---

Create an Interactive Greeting Program

Try:

print("Enter your name:")

if let name = readLine() {
    print("Welcome to Swift, \(name)!")
} else {
    print("Unable to read your name.")
}

This uses optional binding with:

if let

which safely handles the result returned by readLine().

---

Create an Interactive Addition Program

Reading numbers requires converting the text returned by readLine() into a numeric type.

Example:

print("Enter first number:")

let firstInput = readLine()

print("Enter second number:")

let secondInput = readLine()

if let firstText = firstInput,
   let secondText = secondInput,
   let firstNumber = Int(firstText),
   let secondNumber = Int(secondText) {

    let total = firstNumber + secondNumber

    print("Total: \(total)")

} else {
    print("Please enter valid numbers.")
}

Example:

Enter first number:
10

Enter second number:
20

Total: 30

This small program introduces several real programming concepts:

• User input
• Optionals
• Type conversion
• Conditional validation
• Arithmetic
• Output

---

Run Swift Code Using Xcode

Terminal is excellent for learning basic Swift.

However, if your goal is iOS development, you will eventually spend much of your time inside Xcode.

There are different ways to practice Swift using Xcode.

---

Method 3: Create a Swift Playground

A playground provides an environment for experimenting with Swift code without building a complete application.

Depending on your Xcode version, create a new playground through the available Xcode project/file creation options.

Choose an appropriate platform and create a blank playground if available.

Add:

import Foundation

print("Hello, Swift!")

Run the playground.

You can experiment with:

let name = "Alex"
let age = 25

print("Name: \(name)")
print("Age: \(age)")

Playgrounds are useful for:

• Learning syntax
• Testing algorithms
• Experimenting with functions
• Understanding data types
• Trying framework APIs

---

Method 4: Run Swift in an Xcode Command-Line Project

You can also create a command-line project in Xcode.

Open Xcode and create a new project.

Choose the command-line tool template available for macOS development.

Set:

Language: Swift

Xcode creates a project containing Swift source code.

You can add:

print("My first Swift program in Xcode!")

Press:

Command + R

to run the project.

The output appears in Xcode’s debug console.

---

Build vs Run in Xcode

These two operations are related but different.

Build

Keyboard shortcut:

Command + B

Building asks Xcode to compile the project and report build errors.

Run

Keyboard shortcut:

Command + R

Running builds the application if necessary and then executes it.

A simplified workflow is:

Swift Source Code
      ↓
Build
      ↓
Compiler
      ↓
Executable/App
      ↓
Run

---

Your First SwiftUI Program

Once you understand basic Swift syntax, you can create a simple graphical application.

A minimal SwiftUI view might look like:

import SwiftUI

struct ContentView: View {

    var body: some View {
        Text("Hello, Swift!")
    }
}

Instead of printing text in Terminal, this displays text inside an application interface.

This is an important transition:

Command-Line Swift
       ↓
Learn Programming Fundamentals
       ↓
SwiftUI
       ↓
Build User Interfaces
       ↓
Create iOS Apps

---

Add a Button to Your First SwiftUI App

For example:

import SwiftUI

struct ContentView: View {

    var body: some View {
        Button("Tap Me") {
            print("Button tapped!")
        }
    }
}

When the button is tapped, the message:

Button tapped!

appears in Xcode’s debug console.

This demonstrates how Swift code responds to user interaction.

---

Create a Simple Counter with SwiftUI

A slightly more practical beginner example is:

import SwiftUI

struct ContentView: View {

    @State private var count = 0

    var body: some View {

        VStack(spacing: 20) {

            Text("Count: \(count)")
                .font(.largeTitle)

            Button("Increase") {
                count += 1
            }
        }
        .padding()
    }
}

Each button tap increases the number displayed on screen.

This is much closer to real application development.

However, if concepts such as:

@State
View
VStack
body

look unfamiliar, don’t worry.

Learn Swift fundamentals first, then study SwiftUI separately.

---

Understanding Swift Compiler Errors

Your code will not always work.

That is completely normal.

For example:

let age: Int = "Twenty"

Swift produces an error because:

Int

expects an integer, but:

"Twenty"

is a string.

Correct version:

let age: Int = 20

---

Example: Missing Quotation Mark

Incorrect:

print("Hello Swift)

Swift cannot correctly parse the string.

Correct:

print("Hello Swift")

---

Example: Misspelled Function

Incorrect:

Print("Hello")

Swift is case-sensitive.

The correct function is:

print("Hello")

These are not the same:

print
Print
PRINT

---

Example: Changing a Constant

Incorrect:

let score = 10

score = 20

You declared:

score

using let, so it cannot be reassigned.

If the value needs to change, use:

var score = 10

score = 20

---

Example: File Not Found

Suppose you run:

swift hello.swift

and Terminal reports that the file does not exist.

Check your current directory:

pwd

Then list files:

ls

Make sure:

hello.swift

appears in the directory.

If not, move to the correct folder using:

cd folderName

---

Example: Swift Command Not Found

If:

swift --version

does not work, your Swift development tools may not be installed or configured.

If you are on macOS, verify your Xcode or Xcode Command Line Tools setup.

You can check the active developer directory:

xcode-select -p

If you have not installed Apple’s command-line developer tools, macOS can normally start their installation with:

xcode-select --install

If your goal is iOS development, install and configure Xcode.

---

Example: Permission Denied When Running an Executable

Normally, an executable produced by:

swiftc hello.swift -o hello

should be runnable using:

./hello

If you are manually working with another executable file and permissions are incorrect, Unix permissions may need to be investigated.

Do not randomly use chmod on files unless you understand why permission changes are necessary.

For a freshly compiled Swift executable, first verify that compilation actually succeeded and that you are running the correct file.

---

Useful Terminal Commands While Learning Swift

Here are some useful commands.

Check Swift

swift --version

Check Compiler

swiftc --version

Show Current Folder

pwd

List Files

ls

Create Folder

mkdir SwiftPractice

Enter Folder

cd SwiftPractice

Move Back

cd ..

Create Swift File

touch hello.swift

Run Swift File

swift hello.swift

Compile Swift File

swiftc hello.swift

Compile with Custom Name

swiftc hello.swift -o myprogram

Run Executable

./myprogram

Clear Terminal

clear

These basic commands are enough for many beginner exercises.

---

Your First Swift Practice Challenge

Now try writing this program without copying the complete solution.

Create:

profile.swift

Your program should contain:

• Name
• Age
• City
• Programming language
• Whether you are learning iOS development

Expected output might look like:

=== Developer Profile ===
Name: Alex
Age: 25
City: Jaipur
Language: Swift
Learning iOS: Yes

Try solving it using:

let
print()
String interpolation

One possible solution is:

let name = "Alex"
let age = 25
let city = "Jaipur"
let language = "Swift"
let learningIOS = true

print("=== Developer Profile ===")
print("Name: \(name)")
print("Age: \(age)")
print("City: \(city)")
print("Language: \(language)")
print("Learning iOS: \(learningIOS ? "Yes" : "No")")

---

Second Swift Practice Challenge

Create a program that stores two numbers and displays:

• Addition
• Subtraction
• Multiplication
• Division

For example:

First Number: 20
Second Number: 10

Addition: 30
Subtraction: 10
Multiplication: 200
Division: 2

Try solving it yourself before looking back at the calculator example.

---

Third Swift Practice Challenge

Create a program containing:

let marks = 85

Your program should print:

Excellent

when marks are 90 or above.

Print:

Good

when marks are 75–89.

Print:

Pass

when marks are 50–74.

Otherwise print:

Fail

This helps you practice if, else if, and else.

---

Fourth Swift Practice Challenge

Create an array:

let languages = ["Swift", "Kotlin", "Dart", "Java"]

Use a loop to print:

Learning Swift
Learning Kotlin
Learning Dart
Learning Java

This practices:

Arrays + for-in loops + String interpolation

---

Fifth Swift Practice Challenge

Create:

func square(number: Int) -> Int

The function should return the square of a number.

Calling:

square(number: 5)

should produce:

25

This practices:

• Functions
• Parameters
• Return values
• Arithmetic

---

Best Way to Practice Your First Swift Programs

Do not simply copy examples.

Use this process:

Read Example
     ↓
Type It Yourself
     ↓
Run It
     ↓
Change Values
     ↓
Break Something
     ↓
Read Error
     ↓
Fix Error
     ↓
Add Another Feature

For example, start with:

print("Hello")

Then change it:

let name = "Alex"

print("Hello, \(name)")

Then:

let name = "Alex"
let age = 25

print("Hello, \(name). You are \(age) years old.")

Then create a function.

Then request user input.

Small improvements teach programming much more effectively than copying a large application immediately.

---

Recommended Learning Order After Your First Program

Once you can confidently create and run .swift files, follow this order:

First Swift Program
        ↓
Variables & Constants
        ↓
Data Types
        ↓
Operators
        ↓
Strings
        ↓
If-Else
        ↓
Switch
        ↓
Loops
        ↓
Arrays
        ↓
Sets
        ↓
Dictionaries
        ↓
Functions
        ↓
Optionals
        ↓
Structs
        ↓
Classes
        ↓
Enums
        ↓
Closures
        ↓
Protocols
        ↓
Extensions
        ↓
Error Handling
        ↓
Async/Await
        ↓
SwiftUI
        ↓
Build iOS Projects

You don’t need to master every topic before moving forward.

Practice each concept with small programs.

---

Terminal Swift vs Xcode: Which Should Beginners Use?

Use both for different purposes.

Terminal Swift

Excellent for:

• Learning syntax
• Variables
• Conditions
• Loops
• Functions
• Collections
• Small algorithms
• Command-line programs

Xcode

Essential when moving toward:

• SwiftUI
• UIKit
• iOS applications
• macOS applications
• Simulators
• Debugging
• App signing
• Apple platform SDKs

A good beginner progression is:

Simple Swift Files
       ↓
Terminal
       ↓
Swift Fundamentals
       ↓
Xcode
       ↓
SwiftUI
       ↓
iOS Applications

---

Common Beginner Questions

What is the first program to write in Swift?

The traditional first program is:

print("Hello, World!")

It teaches you how to create Swift code and see program output.

How do I run a Swift file?

For a simple Swift script:

swift filename.swift

For example:

swift hello.swift

How do I compile a Swift program?

Use:

swiftc hello.swift

Or:

swiftc hello.swift -o hello

Then run:

./hello

What is a .swift file?

A file ending in:

.swift

is a Swift source-code file.

For example:

main.swift
calculator.swift
profile.swift
hello.swift

What is swiftc?

swiftc is the Swift compiler command.

It compiles Swift source code into executable code.

What does ./hello mean?

The ./ tells your shell to execute the file named hello from the current directory.

Can I run Swift without Xcode?

You can work with command-line Swift when the required Swift toolchain is installed.

However, Xcode is central to native Apple-platform application development.

Can I run Swift code in Terminal?

Yes.

For example:

swift hello.swift

Can I write Swift in a normal text editor?

Yes.

A .swift file is a text-based source file.

However, development environments such as Xcode provide features such as:

• Syntax highlighting
• Code completion
• Build tools
• Debugging
• Project management
• Simulator integration

which become increasingly useful as projects grow.

Should I learn Swift in Terminal or Xcode?

For basic syntax, either is fine.

For iOS development, you should become comfortable with Xcode.

Do I need an iPhone to run my first Swift program?

No.

A simple command-line Swift program can run directly on a Mac.

For iOS applications, Xcode also provides simulators, so you can begin without a physical iPhone.

Real-device testing becomes important later.

Is Swift case-sensitive?

Yes.

For example:

name
Name
NAME

can represent different identifiers.

Similarly:

print("Hello")

is correct, while:

Print("Hello")

does not call the same standard function.

---

Quick Swift First Program Cheat Sheet

Check Swift

swift --version

Create Folder

mkdir SwiftPractice

Open Folder

cd SwiftPractice

Create File

touch hello.swift

First Code

print("Hello, World!")

Run

swift hello.swift

Compile

swiftc hello.swift -o hello

Run Compiled Program

./hello

Variable

var age = 20

Constant

let name = "Alex"

String Interpolation

print("Hello, \(name)")

Condition

if age >= 18 {
    print("Adult")
}

Loop

for number in 1...5 {
    print(number)
}

Function

func greet(name: String) {
    print("Hello, \(name)")
}

---

Final Thoughts

Running your first Swift program is an important milestone because it transforms programming from theory into something you can actually see working.

The basic process is simple:

Install Swift
     ↓
Open Terminal
     ↓
Create hello.swift
     ↓
Write Swift Code
     ↓
Run with swift
     ↓
Compile with swiftc
     ↓
Run Executable
     ↓
Experiment with Code

Start with:

print("Hello, World!")

Then gradually add:

Variables
   ↓
Calculations
   ↓
Conditions
   ↓
Loops
   ↓
Arrays
   ↓
Functions
   ↓
User Input

Once you are comfortable writing and running these small programs, move into SwiftUI and Xcode projects to begin building real Apple applications.

Your first Swift program does not need to be impressive.

Its purpose is to teach you the most important development cycle:

Write code → run it → inspect the result → find mistakes → fix them → improve the program.

That same cycle continues whether you are writing a five-line beginner program or building a complete production iOS application.