What is Prism?

Prism is a full-stack Swift ecosystem built entirely on Apple frameworks — zero third-party dependencies. 10 modules covering everything from SwiftUI components and state management to HTTP servers, ML/AI, and native platform APIs.

UI & Design System

100+ SwiftUI components, design tokens, theming, charts, forms, and accessibility.

Architecture

Composable state management with stores, reducers, effects, middleware, and navigation.

Server

HTTP server, routing, database, GraphQL, MCP, WebSocket rooms, middleware, and cron.

Intelligence

On-device ML, Apple Intelligence, NLP, RAG pipelines, and structured output parsing.

Hello World

iOS App
Server API
Networking
Storage

import Prism

struct CounterFeature: PrismReducer {
    struct State: Sendable, Equatable { var count = 0 }
    enum Action: Sendable { case increment, decrement }

    func reduce(into state: inout State, action: Action) -> PrismEffect<Action> {
        switch action {
        case .increment: state.count += 1
        case .decrement: state.count -= 1
        }
        return .none
    }
}

struct CounterView: View {
    let store: PrismStore<CounterFeature.State, CounterFeature.Action>

    var body: some View {
        VStack {
            Text("\(store.state.count)")
                .prismTypography(.headlineLarge)
            HStack {
                PrismButton("-", variant: .outlined) { store.send(.decrement) }
                PrismButton("+", variant: .filled) { store.send(.increment) }
            }
        }
    }
}

import PrismServer

let server = PrismHTTPServer(port: 8080)

await server.get("/") { request in
    .json(["message": "Hello, Prism!"])
}

await server.get("/users/:id") { request in
    let id = request.parameters["id"]!
    .json(["id": id, "name": "Alice"])
}

try await server.start()

import PrismNetwork

struct UserEndpoint: PrismEndpoint {
    typealias Response = [User]
    let path = "/users"
    let method: PrismHTTPMethod = .get
}

let client = PrismHTTPClient(baseURL: "https://api.example.com")
let users = try await client.request(UserEndpoint())

import PrismStorage

let store = PrismDefaultsStore(suite: "com.app.settings")
try store.save(user, forKey: "currentUser")
let user: User = try store.load(forKey: "currentUser")

let encrypted = PrismEncryptedStore(wrapping: store, key: symmetricKey)
try encrypted.save(secrets, forKey: "tokens")

No configuration files, no boilerplate, no dependency resolution. Just Swift.

Why Prism?

Zero Dependencies

No SwiftNIO, no Alamofire, no third-party anything. Your Package.resolved stays clean. Your builds stay fast.

Swift 6.3 Native

Built from the ground up with strict concurrency. Actors, Sendable, structured concurrency — designed for it.

Full-Stack Ecosystem

10 modules spanning server, client, architecture, networking, ML, and platform APIs. One framework, one import.

How does Prism compare?

vs. Client Frameworks
vs. Server Frameworks

Feature	Prism	TCA	Raw SwiftUI
State Management	PrismStore — composable, middleware, time-travel	ComposableArchitecture	Manual ObservableObject
UI Components	100+ built-in, design tokens, theming	None	None
HTTP Client	Built-in, type-safe endpoints, cache, retry	None	URLSession
Storage	6 backends, encryption, compression, migration	None	UserDefaults / SwiftData
Security	Biometrics, keychain, cert pinning, JWT	None	Manual
ML/AI	CoreML, Apple Intelligence, RAG	None	None
Gamification	Challenges, streaks, leaderboards	None	None
Dependencies	0	3+	0

Feature	Prism	Vapor	Hummingbird
Third-party deps	0	20+	10+
HTTP layer	Network.framework	SwiftNIO	SwiftNIO
Database	Built-in SQLite	Fluent	Custom
GraphQL	Built-in	Third-party	Third-party
MCP Server	Built-in	None	None
WebSocket Rooms	Built-in	Manual	Manual
Client SDK	Full UI + Architecture + Network	None	None
Swift 6 concurrency	Native actors	Partial	Partial

The Ecosystem

Prism is organized into 10 focused modules that work together or independently:

Client
Server

Module	Role
PrismUI	100+ SwiftUI components, 4 themes, design tokens
PrismArchitecture	Store, reducer, middleware, router (UDF)
PrismNetwork	HTTP client, WebSocket, endpoints, cache, retry
PrismFoundation	Entities, logging, analytics, locale, resources
PrismSecurity	Biometrics, keychain, encryption, cert pinning, JWT
PrismStorage	UserDefaults, Disk, Memory, SwiftData, Keychain
PrismIntelligence	CoreML, Apple Intelligence, LLM, RAG, NLP
PrismGamification	Challenges, streaks, badges, leaderboards
PrismCapabilities	StoreKit, HealthKit, CloudKit, Camera, NFC
PrismVideo	Video download, media entities

Module	Role
Core	HTTP server, routing, request/response
Middleware	CORS, auth, rate limiting, compression, logging
Database	SQLite, query builder, models, migrations
Real-Time	WebSocket, rooms, SSE, events
Content	JSON, multipart, file upload, streaming, templates
GraphQL	Schema, queries, mutations, playground
MCP	AI tool server, resources, transports
Infrastructure	Config, health, metrics, cron, cluster
Advanced	DI, tracing, versioning, OpenAPI, cache
Testing	Test client, request builder, assertions

Real Examples

iOS App with State
Networking + Security
Server API

A todo app with PrismArchitecture, PrismUI components, and PrismStorage:

import Prism

struct TodoFeature: PrismReducer {
    struct State: Sendable, Equatable {
        var todos: [Todo] = []
        var input = ""
    }

    enum Action: Sendable {
        case addTodo, updateInput(String), toggleTodo(UUID), loaded([Todo])
    }

    let storage = PrismDefaultsStore(suite: "com.app.todos")

    func reduce(into state: inout State, action: Action) -> PrismEffect<Action> {
        switch action {
        case .addTodo:
            let todo = Todo(title: state.input)
            state.todos.append(todo)
            state.input = ""
            return .run { _ in try storage.save(state.todos, forKey: "todos") }
        case .updateInput(let text):
            state.input = text
        case .toggleTodo(let id):
            state.todos[id: id]?.isDone.toggle()
            return .run { _ in try storage.save(state.todos, forKey: "todos") }
        case .loaded(let todos):
            state.todos = todos
        }
        return .none
    }
}

struct TodoListView: View {
    let store: PrismStore<TodoFeature.State, TodoFeature.Action>

    var body: some View {
        PrismCard {
            ForEach(store.state.todos) { todo in
                PrismListItem(todo.title, trailing: {
                    PrismCheckbox(isOn: todo.isDone) {
                        store.send(.toggleTodo(todo.id))
                    }
                })
            }
            HStack {
                PrismTextField("New todo", text: Binding(
                    get: { store.state.input },
                    set: { store.send(.updateInput($0)) }
                ))
                PrismButton("Add", variant: .filled) {
                    store.send(.addTodo)
                }
            }
        }
    }
}

Type-safe API client with certificate pinning and encrypted token storage:

import PrismNetwork
import PrismSecurity
import PrismStorage

struct LoginEndpoint: PrismEndpoint {
    typealias Response = AuthResponse
    let path = "/auth/login"
    let method: PrismHTTPMethod = .post
    let body: LoginRequest
}

let pin = PrismCertificatePin(
    host: "api.myapp.com",
    publicKeyHash: PrismCertificatePin.hash(publicKeyDER: certData)
)
let validator = PrismPinningValidator(pins: [pin], policy: .strict)

let client = PrismHTTPClient(baseURL: "https://api.myapp.com")
let auth = try await client.request(LoginEndpoint(body: credentials))

let secureStore = PrismEncryptedStore(
    wrapping: PrismKeychainStore(),
    key: symmetricKey
)
try secureStore.save(auth.token, forKey: "accessToken")

REST API with database, middleware, and validation:

import PrismServer

let server = PrismHTTPServer(port: 8080)
let db = try PrismDatabase(path: "tasks.db")

let migrator = PrismMigrator(database: db)
try await migrator.migrate([
    PrismMigration(
        name: "create_tasks",
        up: "CREATE TABLE tasks (id INTEGER PRIMARY KEY, title TEXT NOT NULL, done INTEGER DEFAULT 0)",
        down: "DROP TABLE tasks"
    )
])

await server.use(PrismCORSMiddleware())
await server.use(PrismLoggingMiddleware())

await server.get("/tasks") { request in
    let rows = try await db.table("tasks").orderBy("id", ascending: false).get()
    return .json(rows)
}

await server.post("/tasks") { request in
    let result = request.validateJSON { v in
        v.field("title", .required, .minLength(1), .maxLength(200))
    }
    if let error = result.errorResponse() { return error }
    let title = request.formData["title"] ?? ""
    let id = try await db.table("tasks").insert(["title": .text(title)])
    return .json(["id": id, "created": true], status: .created)
}

try await server.start()

What Can You Build?

Native iOS/macOS Apps

Full-featured apps with PrismUI components, PrismArchitecture state management, and PrismNetwork.

REST APIs

JSON APIs with routing, validation, authentication, rate limiting, and database persistence.

Real-Time Apps

Chat, live dashboards, collaborative tools using WebSocket rooms, SSE, and the event bus.

ML-Powered Features

On-device classification, sentiment analysis, RAG pipelines, and Apple Intelligence.

GraphQL & MCP Servers

GraphQL schemas with playground, MCP servers exposing tools to AI assistants.

Gamified Experiences

Challenges, streaks, badges, leaderboards, and AI-powered motivational messages.

Next Steps

Install Prism

Add Prism to your Swift package — server, client, or both. Installation guide

Build Something

Follow the quickstart — choose iOS App or Server API. Quickstart

Explore Modules

UI Components / Architecture / Network / Storage / Security / Server / Intelligence / Gamification

​What is Prism?