Creating a Photographic Timeline on iPhone with Apple Intelligence and Without iCloud

AirDrop is the only solution

I’m lucky enough to have footage and photos from my birth. My father was taking videos when video cameras weighed many kilos, and later my brother intuitively started documenting his life, and mine. Naturally, I picked up these habits.

I wanted to have a photographic timeline of my life and create memory compilations. The best solution I could think of is using Apple iOS Photos.

The Problem

I appreciate Apple’s approach to privacy, the majority of computation is done on-device. That includes Apple Photos Intelligence features. My goal is to create a photographic timeline of my life, and have it processed on-device. I don’t want to use iCloud for a couple of reasons:

• My library is too large for my current iCloud plan (30 years of photos and videos) and it barely fits in my current iPhone (256GB)

• I’m eliminating subscriptions where possible

• I want to have full control over syncing (e.g., impossible with iCloud Photos as it syncs everything in the library)

• I want to manage my library independently of any single machine

Since the iPhone 4 era, I’ve synced photos via iTunes/Finder. This method still works, but photos synced this way don’t work with Apple Intelligence features. They end up in a separate internal directory that isn’t available for Apple Intelligence to process; this means no Memories, no intelligent search, no automatic organization.

Disclaimer: This is a manual process with no automation or magical solutions. I’m sharing it primarily to document what doesn’t work and why. If you have a better solution that meets these requirements, I’d love to hear about it!

What doesn’t work

• Syncing via Finder from a folder

• Syncing from Photos.app without iCloud

• Third-party sync tools (none found from my research)

In all cases, synced photos, end up in a separate internal iOS directory that is not available to Apple’s Photos Features.

Only AirDrop (and direct import via iOS Files app) places photos in the correct directory for full Apple Intelligence functionality.

AirDrop Workflow

Organize your source library

Create a main directory to store copies of all the photos you want on your iPhone. Inside the main directory, photos should be organized by year; I find this makes sorting and tracking transfers easier.

Prepare your photos

• Convert to JPEG/HEIC format. I keep RAW files in a separate archive, off-device

• Ensure that exported or edited photos have the right creation time, otherwise they will appear in the wrong place in your photos library. Some apps overwrite creation dates when exporting. I’ll show how to fix that below.

Airdrop

To my experience batches of around 400 photos are the most reliable transfers. Larger batches might fail.

Worth a try: there are reports for wired AirDrops which can be faster than wireless. For me, it didn’t seem to work, and also I couldn’t find any official Apple documentation.

Tip: Some users report faster transfers with wired AirDrop (iPhone connected via cable), though I haven’t noticed a difference and Apple doesn’t officially document this feature.

Once transferred, your photos will appear in the native Photos app with full access to Memories, intelligent search, and all other Apple Intelligence features.

That’s it.

Alternative: External Drive

Instead of AirDrop, you can connect an external drive containing your main folder directly to your iPhone and import photos through the Files app. However, I prefer to do it over AirDrop as I find it easier to manage files in MacOS.

A perk that comes with self-managing your library is that both solutions work interchangeably; you can AirDrop and you can import via a drive when traveling.

Backup of your main

Your main folder serves as your backup. You can consider additional backups using standard tools like Time Machine or rsync.

Backing Up Photos From Your iPhone

One trade-off with this approach is that backing up photos shot on your phone can become more complicated.

I’ve always used Image Capture to back up iPhone photos. The problem is that AirDropped photos now live in your native iPhone library alongside photos you actually took with your device. The Download All button in Image Capture no longer works cleanly as it would download everything, including photos you already have in your main folder. Duplicates will become a thing.

Image Capture shows Maker and Model fields but doesn’t let you filter by them, so you can’t easily isolate iPhone camera photos from AirDropped content from other sources.

Workarounds

If you back up regularly, you can sort by date in Image Capture and select only recent photos. This works well for if you’re consistent with your backup schedules.

Otherwise, you can AirDrop back to your Mac. This lets you filter in the iOS photos app by device, date, or any other metadata.

This solution is far from friction-less, but it works. If you want full control over your photo library with complete Apple Intelligence features and no iCloud dependency, manually syncing with AirDrop is currently the only viable option.

Tools & Scripts

Here are scripts and commands I use for this workflow. Adapt them to your needs. I prefer a programmatic approach over GUI tools mainly for speed.

Important: Always work on copies of your photos in a separate directory. Place the script in that directory and run it.

Prerequisites: Basic familiarity with Terminal and running shell scripts. If you’re new to this, consider using GUI apps.

Transcoding

I have a large number of photos in lossless formats (e.g., TIF). I want to compress them to JPEG or HEIC and preserve their creation dates so they appear in the correct order in my timeline.

#!/bin/bash

# Convert images and preserve original creation dates
# Usage: ./convert-and-preserve-dates.sh <INPUT_FORMAT> [OUTPUT_FORMAT]
# Examples: 
#   ./convert-and-preserve-dates.sh TIF           (converts to JPEG)
#   ./convert-and-preserve-dates.sh TIF heic      (converts to HEIC)
#   ./convert-and-preserve-dates.sh PNG jpg       (converts to JPEG)

if [ $# -eq 0 ]; then
    echo “Error: No input format specified”
    echo “Usage: $0 <INPUT_FORMAT> [OUTPUT_FORMAT]”
    echo “Examples:”
    echo “  $0 TIF           (converts to JPEG by default)”
    echo “  $0 TIF heic      (converts to HEIC)”
    echo “  $0 PNG jpg       (converts to JPEG)”
    exit 1
fi

INPUT_FORMAT=”$1”
OUTPUT_FORMAT=”${2:-jpg}”  # Default to jpg if not specified

# Check if ImageMagick is installed
if ! command -v magick &> /dev/null; then
    echo “Error: ImageMagick is not installed”
    echo “Install it with: brew install imagemagick”
    exit 1
fi

# Check if any files with the specified format exist
if ! ls *.”$INPUT_FORMAT” 1> /dev/null 2>&1; then
    echo “Error: No .$INPUT_FORMAT files found in current directory”
    exit 1
fi

echo “Converting *.$INPUT_FORMAT to $OUTPUT_FORMAT...”
magick mogrify -format “$OUTPUT_FORMAT” *.”$INPUT_FORMAT”

echo “Preserving original dates...”
for f in *.”$INPUT_FORMAT”; do
  original_date=$(stat -f %Sm -t “%Y%m%d%H%M.%S” “$f”)
  converted_file=”${f%.$INPUT_FORMAT}.$OUTPUT_FORMAT”
  
  if [ -f “$converted_file” ]; then
    touch -t “$original_date” “$converted_file”
    echo “  ✓ ${converted_file}”
  else
    echo “  ✗ Failed to convert: $f”
  fi
done

echo “Done! Converted $(ls -1 *.$OUTPUT_FORMAT 2>/dev/null | wc -l | xargs) files to $OUTPUT_FORMAT.”

Setting Dates

I have scanned film photos where I know the shooting date (encoded in filenames or recalled from memory by comparing with iPhone photos from that timeSetting exact timestamps is unrealistic, but at least having the correct date is important for timeline ordering. This script sets dates for JPEG files.

#!/bin/bash

# Usage: ./set_creation_date.sh DD-MM-YYYY

input_date=$1
if [[ -z “$input_date” ]]; then
  echo “Usage: $0 DD-MM-YYYY”
  exit 1
fi

# Convert DD-MM-YYYY to MM/DD/YYYY (SetFile format)
day=${input_date:0:2}
month=${input_date:3:2}
year=${input_date:6:4}
formatted_date=”$month/$day/$year 00:00:00”

# Iterate over jpeg files in current directory
for file in *.jpg *.jpeg *.JPG *.JPEG; do
  if [ -f “$file” ]; then
    echo “Setting creation date of $file to $formatted_date”
    SetFile -d “$formatted_date” “$file”
  fi
done

Tip: You can adjust metadata (date, location) directly in the iOS Photos app. Tap a photo → swipe up → tap “Adjust” next to the date or location.

Preserving Dates for Edited Videos

I have large videos, and I keep some parts for my timeline. When I export the edited video from DaVinci Resolve, or any other editor, the creation date reflects the date of the export. To maintain timeline ordering I copy the creation date of the original video to the exported one.

touch -r /path/to/original/video.MP4 /path/to/exported/video.mp4

These scripts are suggestions for your workflow, mainly to inspire what you can do with CLI tools to work more efficiently.

Flattening Directories

Recursively finds all files (not directories) located at least two levels deep within the source directory and then moves each of those files into the destination directory.

find /path/to/source -mindepth 2 -type f -exec mv -i '{}' /path/to/destination \;

Final Thoughts

It’s certainly easier to do this via a cloud service. But if you value control, privacy and freedom from subscriptions, AirDrop is currently the only option for accessing Apple Intelligence features in Photos without iCloud.

I hope Apple eventually adds proper local sync to Finder that works with on-device processing. Until then, this is the workaround.

I’ll update this post as I refine my workflow. If you find something better, let me know.