We set out to build Dillo with two questions in mind, not "can we make an archive app?" but rather: how well does Swift's C interop actually work? And: can you build a real macOS app almost entirely through agentic coding?

Dillo became the answer to both.

The C Interop Question

Swift is great at many things, but interfacing with battle-tested C libraries is where it gets interesting. We wanted to wrap libarchive, a powerful C library that handles virtually every archive format out there, and turn it into a proper Swift package. No Objective-C bridging headers, no shims. Just Swift talking to C.

The key to making this work is a module.modulemap, a small file that tells Swift how to import the C headers:

module CLibArchive {
    header "archive.h"
    header "archive_entry.h"
    link "xml2"
    export *
}

Six lines that bridge two worlds. With this in place, Swift can directly call into libarchive's C API, archive_read_open, archive_entry_pathname, all of it, without any wrapper code. From there, we built a Swift-idiomatic layer on top.

That C bridge becomes a clean Swift API on top, here's what using SwiftArchive actually looks like:

// Extract an archive
try Archive.extract(url: archiveURL, to: destinationURL)

// Create a ZIP from files
try Archive.create(files: [file1, file2], to: archiveURL)

// Encrypted archive with progress
try Archive.create(
    files: files,
    to: archiveURL,
    format: .zip,
    encryption: .aes256,
    password: "secret"
) { file, progress in
    print("\(file.lastPathComponent): \(Int(progress * 100))%")
}

// Format detection
let (format, compression) = try Archive.detectFormat(url: someURL)

The result is SwiftArchive, an open-source Swift package that wraps libarchive with a clean, idiomatic API. ZIP, RAR, 7z, TAR, ISO, and a dozen more formats, all accessible through Swift.

The Agentic Coding Question

The second experiment was more radical. Could we use AI-assisted agentic coding, specifically Claude Code, to go from "we have a Swift package" to "we have a production-ready macOS app on the App Store"?

The answer: surprisingly, yes. The bulk of Dillo's SwiftUI interface, the drag-and-drop architecture, the accessibility implementation, even the App Store submission materials, screenshots, descriptions, privacy policy, were built in collaboration with AI. Not generated and forgotten, but iteratively developed, reviewed, and refined.

What worked well: scaffolding views, generating accessibility labels and identifiers, creating marketing assets, navigating the surprisingly complex App Store submission process. What still needed a human: architectural decisions, the subtle UX choices that make a utility app feel right, and debugging the occasional sandbox entitlement issue that no AI could have anticipated.

The Result

Dillo is a drag-and-drop archive utility for macOS. It compresses and extracts files, supports 15+ formats, offers AES-256 encryption, and does it all without ever connecting to the internet.

But more than the app itself, Dillo validated two ideas for us: Swift's C interop and agentic coding isn't replacing developers, it's giving solo developers the bandwidth to ship things in solo mode.

Download Dillo on the Mac App Store →