Gradiente

Gradiente is a simple library for iOS to apply a blurry, coloured and vibrant background behind your views. It's written in SwiftUI and easily applicable to any view.

Features

• Support for colours and gradients
• Can be applied as a SwiftUI modifier to any view
• Can be positioned at the top or bottom of the view
• Compatible with iOS 15

Requirements

• Xcode 13 and later
• iOS 15 and later
• Swift 5.5 and later

License

This library is licensed under the MIT License.

MacAppSettingsUI

MacAppSettingsUI is a package designed to simplify the process of implementing structured settings or preferences user interfaces for macOS applications built using the AppKit framework. This package aims to streamline the development of intuitive and consistent settings interfaces, which are common features in many desktop applications.

By leveraging MacAppSettingsUI, developers can easily create and manage a hierarchical structure for their application's settings or preferences. This structure can be organized into various sections, each containing related settings or configuration options.

FullDiskAccess

FullDiskAccess is a Swift package designed to simplify the process of querying and prompting for Full Disk Access permission on macOS 10.14 and later versions. This package aims to address the challenges developers face when their macOS applications require access to system files or files belonging to other applications.

Full Disk Access is necessary for non-sandboxed macOS applications that need to access restricted areas of the file system, such as system files or files owned by other applications. Examples of such applications include file backup utilities, system-wide search tools, and other applications that require comprehensive access to the user's disk.

While the lack of clear documentation surrounding Full Disk Access has led to confusion within the developer community, this Swift package aims to provide a streamlined solution. The package's developer has thoroughly tested the behavior across six different macOS virtual machines to ensure a comprehensive understanding of the permission requirements and their nuances across various macOS versions.

FullDiskAccess offers a straightforward API that enables developers to check the current Full Disk Access permission status and prompt users to grant the necessary permissions when required. By encapsulating this functionality within a dedicated package, developers can save time and effort while ensuring their applications comply with macOS security requirements and provide the necessary access required for their intended functionality.

Vision Panes

Vision Panes is an easy-to-use SwiftUI package designed to simplify the process of splitting windows into multiple panes with smooth animations out of the box. This package aims to enhance the user experience of visionOS applications by leveraging the platform's unique infinite canvas feature.

One of the key advantages of visionOS is its ability to display windowed apps with arbitrary sizes, enabling developers to utilize panes more effectively without compromising screen real estate. Apple has implemented this concept in the Messages app, where contact details are displayed in a pane on the trailing edge of the main pane, providing a seamless and space-efficient user experience.

While visionOS offers this functionality, setting up panes can be a complex and challenging task without proper tools. Vision Panes addresses this issue by providing a simple SwiftUI interface, eliminating the need for developers to delve into UIKit for window management and plumbing.

Key features of Vision Panes include:

1. Easy-to-use SwiftUI API: Vision Panes offers an intuitive SwiftUI interface familiar to most SwiftUI developers, streamlining the development process.
2. Multiple pane support: Developers can add multiple panes to each of the four edges of a window, enabling flexible and dynamic layouts.
3. No UIKit required: Vision Panes eliminates the need to work with UIKit, allowing developers to stay within the SwiftUI ecosystem.
4. Pleasant animations: The package includes pleasant animations for pane transitions, enhancing the overall user experience.

Vision Panes is compatible with visionOS 1.0, Swift 5.10, and Xcode 15.2, making it accessible to developers working on the latest versions of Apple's platforms and tools. The package is available under the permissive MIT License, allowing for free use, modification, and distribution.

swift-translate

Swift Translate is a powerful command-line interface (CLI) tool and Swift Package Plugin designed to streamline the localization process for app development. It simplifies the task of translating your application's string catalogs into multiple languages by leveraging the capabilities of OpenAI's GPT-3.5-Turbo language model.

The tool works by deconstructing your existing string catalogs and automatically sending the strings to the GPT-3.5-Turbo model for translation. This integration with OpenAI's advanced natural language processing technology ensures accurate and context-aware translations, enabling you to efficiently localize your app for global audiences.

Requirements

• macOS 13+
• Xcode 15+
• Project utilizing String Catalogs for localization
• OpenAI API key

MetaCopy

MetaCopy is a macOS application designed to facilitate the process of copying metadata to images. It provides a user-friendly interface that allows users to effortlessly transfer metadata, such as EXIF data, from one image file to another or multiple image files.

Developed by Jean-David Gadina, MetaCopy aims to simplify a task that can be tedious and time-consuming when performed manually. By automating the metadata copying process, this application streamlines workflows for photographers, graphic designers, and anyone working with large collections of image files.

Spatial Player

The Spatial Player is an example immersive video player specifically designed for the newly released Apple Vision Pro headset. It was developed by Mike Swanson to address the lack of an official playback solution from Apple for spatial and immersive videos, despite the Vision Pro's capability to play such content.

These spatial videos can be recorded using the iPhone 15 Pro, the Vision Pro itself, or created with Mike Swanson's spatial command-line tool and similar utilities. They are encoded using the MV-HEVC codec and contain a Video Extended Usage box with instructions for proper playback.

However, one month after the Vision Pro's launch, Apple had not provided an obvious method to play these immersive videos in their supported formats. As a result, Mike Swanson developed the Spatial Player as a bare-bones solution to test the output from his command-line tool and video samples shared by interested parties. The player has successfully played up to 12K-per-eye (11520x5760) 360-degree stereo content, although at a low frame rate.

Loopover

Loopover is a challenging 2D Rubix Cube style puzzle game. The goal of the game is to slide every box back into its original place. Any box that goes outside the grid will "loopover" back around to the other side. The game can be played in 4 different sizes: 3x3, 4x4, 5x5, and 6x6. Try to come up with the fastest time for each board!

Attribution

Loopover is a recreation of carykh's Loopover written in Processing. We wanted to take the amazing concept of this game and make it more mobile friendly with native swipe gestures, using local storage to save user's best scores, and allowing for offline play. Please check out the original!

ConfettiSwiftUI by simibac

PlanePlopper

The primary way that visionOS augments reality is by detecting planes in the real world and allowing developers to attach objects to them.

PlanePlopper makes it fast and easy to get your project providing immersive RealityKit scenes where users can place objects on (horizonal) planes of their choosing.

mlx-swift-chat

A multi-platform SwiftUI frontend for running local LLMs with Apple's MLX framework.

This project is a fully native SwiftUI app that allows you to run local LLMs (e.g. Llama, Mistral) on Apple silicon in real-time using MLX.

ConfettiWithSpriteView

A SwiftUI confetti modifier created by SpriteKit. Easily to use and custom in SwiftUI.

Preview

Installation

In Xcode go to File -> Swift Packages -> Add Package Dependency
and paste in the repo's url:

https://github.com/VIkill33/ConfettiWithSpriteView.git

Or you can download the code of this repo, then Add Local... in Xcode, and open the folder of the repo.

Usage

• Import this package after you installed by import ConfettiWithSpriteKit
• Use the modifier like(check it out in DemoAPP inside this package)

struct ContentView: View {
    
    @State private var startConfetti = false
    
    var body: some View {
        ZStack {
            Button("Start/Stop") {
                startConfetti.toggle()
            }
            .confetti(start: $startConfetti)
        }
    }
}

When you change the passed var startConfetti to true, confetti will play above your modified view(confetti will NOT handle touch events and will pass them to views underit), and false will stop emitting more confetti.

The var need to be changed to false then true to retrigger the confetti.

Parameters

You can custom colors and images of confetti.

All descriptions about parameters were written in comment in source code:

    /// - Parameters:
    ///   - start: A binding to a boolean value that controls the emission of confetti.
    ///   - angle: The angle at which the confetti will be emitted, measured in radians. Default is pi/2 (90 degrees).
    ///   - colors: An array of `UIColor` values representing the colors of the confetti. Default includes red, green, system teal, yellow, orange, and purple.
    ///   - size: The size of each confetti piece. Default is 25x25 points.
    ///   - scale: The initial scale of the confetti particles. Default is 0.3.
    ///   - numToEmitRange: A closed range of integers specifying the number of particles to emit. Default range is 10 to 20.
    ///   - images: An array of `UIImage` objects representing the images for the confetti. Default includes a ribbon image.

How does it work

It use SKEmitterNode in SpriteKit to emit particles, which are ribbons in this package defaultly. Particles of SKEmitterNode behave similarly to CAEmitterLayer's. This repo is also an example about how to create SKEmitterNodes programmaticaly.

MaskedTextFieldSwiftUI

The MaskedTextFieldSwiftUI package empowers developers to easily integrate customizable masked text input fields into their SwiftUI applications. Masked text fields provide a structured way for users to input data by enforcing a specific format, such as phone numbers, dates, or credit card numbers, while maintaining a clean and intuitive user experience.

Key Features

• Flexible Masking: Define custom masks to specify the format in which user input should be entered, allowing for precise control over the data format.

• Input Validation: Automatically validate user input against the specified mask, ensuring that only valid data is accepted and processed.

• Placeholder Support: Provide placeholders that guide users on the expected format for input, improving usability and reducing errors.

• Dynamic Formatting: Enable dynamic updates to the mask based on user input or application requirements, adapting to various scenarios seamlessly.

• Customization Options: Customize the appearance and behavior of the masked text field to align with the application's design language and user preferences.

• Integration with SwiftUI: Seamlessly integrate the masked text field component into SwiftUI views, leveraging SwiftUI's declarative syntax for building user interfaces.

Whether you're building a form for collecting user information, implementing a payment processing system, or creating any other data entry interface, the SwiftUI Masked Text Field package provides a reliable solution for enforcing data format consistency and enhancing user input experiences in SwiftUI applications.

Installation

Requirements

• iOS 15.0+

Via Swift Package Manager

In Xcode, within your project, select: File > Swift Packages > Add Package Dependency, then paste the URL https://github.com/darealkhan/MaskedTextFieldSwiftUI.git and proceed to download it.

How to Use

To use MaskedTextFieldSwiftUI, you need to follow the simple steps below.

1. Import the package into your project.

import MaskedTextFieldSwiftUI

2. Create two state variables to receive changes in the text field. rawText will contain the cleared text from masked text. You can also use maskedText if needed.

@State var rawText = ""
@State var maskedText = ""

3. Create a MaskType to specify the type of mask. The maskString parameter is a string that replaces mask characters with your typed characters. Separators are used to retrieve raw text from masked text, so each character in separators will be deleted in raw text. Finally, the maskChar parameter specifies which character will be used for masking.

let mastType = MaskType(
    maskString: "####-####-####-####",
    seperators: [
        .emptySpace,
        .customSeperator("-")
    ],
    maskChar: "#"
)

4. Create a MaskedTextFieldConfig for customizing textField related settings. There are numerous options you can customize; below, I'll list them all, and you can select which ones you want to customize.

For example, let's create a simple configuration with a placeholder.

let config = MaskedTextFieldConfig(
    placeHolder: "Card Number"
)

5. Lastly, create a text field with masked text and raw text as binding variables, along with configuration and mask type settings.

 MaskedTextField(
    rawText: $rawTest,
    maskedText: $maskedTest,
    maskType: maskType,
    config: config
)

Example

Real-world example of how you can use MaskedTextFieldSwiftUI can be found in the package files as well

import Foundation
import MaskedTextFieldSwiftUI
import SwiftUI

struct ContentView: View {
    @State private var testFields = TestField.getFields()
    
    var body: some View {
        NavigationView {
            List($testFields) { field in
                Section(field.maskType.wrappedValue.maskString) {
                    textFieldTestView(with: field)
                }
            }
            .navigationTitle("Masked TextField ?")
        }
    }
    
    private func textFieldTestView(
        with field: Binding<TestField>
    ) -> some View {
        VStack {
            MaskedTextField(
                rawText: field.rawText,
                maskedText: field.maskedText,
                maskType: field.maskType.wrappedValue,
                config: field.config.wrappedValue
            )
            
            Divider()
            
            Text("Raw text is: \(field.rawText.wrappedValue)")
                .font(.caption)
                .foregroundStyle(.secondary)
                .frame(
                    maxWidth: .infinity,
                    alignment: .leading
                )
            
            Text("Masked text is: \(field.maskedText.wrappedValue)")
                .font(.caption)
                .foregroundStyle(.secondary)
                .frame(
                    maxWidth: .infinity,
                    alignment: .leading
                )
        }
    }
}

struct TestField: Identifiable {
    let id = UUID()
    var rawText = ""
    var maskedText = ""
    var config: MaskedTextFieldConfig
    var maskType: MaskType
    
    static func getFields() -> [TestField] {
        return [
            .init(
                config: MaskedTextFieldConfig(
                    placeHolder: "Credit Card Number"
                ),
                maskType: .init(
                    maskString: "####-####-####-####",
                    seperators: [
                        .emptySpace,
                        .customSeperator("-"),
                    ]
                )
            ),
            .init(
                config: MaskedTextFieldConfig(
                    placeHolder: "Number"
                ),
                maskType: .init(
                    maskString: "(###)-###-##-##",
                    seperators: [
                        .emptySpace,
                        .customSeperator("("),
                        .customSeperator(")"),
                        .customSeperator("-")
                    ]
                )
            ),
            .init(
                config: MaskedTextFieldConfig(
                    placeHolder: "Zip adress",
                    autocapitalizationType: .allCharacters
                ),
                maskType: .init(
                    maskString: "## ####",
                    seperators: [
                        .emptySpace
                    ]
                )
            ),
            .init(
                config: MaskedTextFieldConfig(
                    placeHolder: "Ip address"
                ),
                maskType: .init(
                    maskString: "###.###.#.#",
                    seperators: [
                        .customSeperator(".")
                    ]
                )
            )
        ]
    }
}

#Preview {
    ContentView()
        .preferredColorScheme(.dark)
}

VerticalSplit

This package is heavily inspired by the splitscreen impelementation from the Amie iOS app.

Usage

import VerticalSplit

VerticalSplit(
    topTitle: "Top View",
    bottomTitle: "Bottom View",
    topView: {
        // Top Content
    },
    bottomView: {
        // Bottom Content
    }
)

Mini Overlays

Add custom content to show when the top or bottom views are in their smallest size.

VerticalSplit(
    topTitle: "Top View",
    bottomTitle: "Bottom View",
    topView: {
        // Top Content
    },
    bottomView: {
        // Bottom Content
    },
    topMiniOverlay: {
        // Shown instead of the Top Content when Top View is minimised
    },
    bottomMiniOverlay: {
        // Shown instead of the Bottom Content when Bottom View is minimised
    }
)

SplitDetent Binding

Use a binding to control the split between the top and bottom views.

@State var currentDetent: SplitDetent.fraction(0.5)

VerticalSplit(
    detent: $currentDetent
    topTitle: "Top View",
    bottomTitle: "Bottom View",
    ...
)

Accessories

Use the leadingAccessories and trailingAccessories modifiers to add buttons in the drag region.

VerticalSplit(...)
    .leadingAccessories([
        SplitAccessory(systemName: "plus.circle.fill") {
            // Perform action
        },
        SplitAccessory(systemName: "minus.circle.fill") {
            // Perform action
        }
    ])

Menu Accessories

Use the menuAccessories modifier to add buttons in a pop-out menu un the drag region.

VerticalSplit(...)
    .menuAccessories([
        MenuAccessory(title: "Plus", systemName: "plus.circle.fill", color: .green) {
            // Perform action
        },
        MenuAccessory(title: "Minus", systemName: "minus.circle.fill", color: .red) {
            // Perform action
        }
    ])

Background Color

Set the background color for the top and bottom view containers, as well as the menu buttons,

VerticalSplit(...)
    .backgroundColor(.gray)

Debugging

Control whether or not logs are made for debugging.

VerticalSplit(...)
    .debug(true)

TodoTrackr

TodoTrackr is your go-to application for seamless task organization and management. With TodoTrackr, users can effortlessly create custom categories, such as "Courses," "Work Projects," or "Personal Errands," tailoring their task management experience to suit their unique needs.

Here's what sets TodoTrackr apart:

Custom Categories

Users have the freedom to create personalized categories, allowing for intuitive organization of tasks based on different aspects of their lives or projects.

Effortless Task Addition

Adding tasks to categories is a breeze. Whether it's jotting down a quick reminder or outlining a detailed to-do list, TodoTrackr ensures that users can capture tasks quickly and efficiently.

CoreData Integration

TodoTrackr leverages CoreData for robust data management, ensuring the reliability and scalability of your task lists. CoreData's efficient data storage and retrieval mechanisms guarantee a seamless user experience, even with extensive task lists.

JSON Export & Import

Need to share your task lists or back them up? TodoTrackr has you covered. With CoreData JSON encoding, users can export all app contents to a JSON file effortlessly. This feature ensures data portability and allows for easy integration with other applications or platforms.

Screenshots

Main View

Add A Todo

Edit A Todo

Files converted to JSON

BetterSlider

This package provides a custom slider control that allows for more customization than the standard Slider control.

Overview

If you need a slider control that allows for more customization than the standard Slider control,
you can use BetterSlider/BetterSlider.

If you need a slider control to select a range of values, you can use BetterSlider/RangeSlider.

Documentation

The documentation is available here.

You can also have a look at the sample project.

Usage

dependencies: [
    .package(url: "https://github.com/lukepistrol/BetterSlider.git", from: <#Version#>)
]