Skiko (Skia for Kotlin)

To use Skiko in your Kotlin project, you must include the appropriate runtime dependency based on your target operating system and architecture. You need to add mavenCentral() and the Compose Dev repository to your repositories block, then compute the target string in the format ${targetOs}-${targetArch} (e.g., macos-arm64, windows-x64, linux-x64).

Common target mappings:

• OS: macos, windows, linux
• Arch: x64 (for x86_64 or amd64), arm64 (for aarch64)

Use the dependency format: org.jetbrains.skiko:skiko-awt-runtime-$target:$version.

    repositories {
        mavenCentral()
        maven("https://redirector.kotlinlang.org/maven/compose-dev")
    }

    val osName = System.getProperty("os.name")
    val targetOs = when {
        osName == "Mac OS X" -> "macos"
        osName.startsWith("Win") -> "windows"
        osName.startsWith("Linux") -> "linux"
        else -> error("Unsupported OS: $osName")
    }

    val osArch = System.getProperty("os.arch")
    val targetArch = when (osArch) {
        "x86_64", "amd64" -> "x64"
        "aarch64" -> "arm64"
        else -> error("Unsupported arch: $osArch")
    }

    val version = "0.8.9" // or any more recent version
    val target = "${targetOs}-${targetArch}"
    dependencies {
        implementation("org.jetbrains.skiko:skiko-awt-runtime-$target:$version")
    }

To create or update a Jump List, use the JumpList.build function. This function provides a JumpListBuilder instance within a block. The builder follows a specific lifecycle:

1. Set AppID: If your application uses an explicit AppUserModelID, call setAppID(appID: String) first.
2. Begin List: Call beginList() to start the transaction. This retrieves the current list and identifies items the user has previously removed (via getRemovedItems()).
3. Add Content: Use addCategory(category: String, items: List<JumpListItem>) to add grouped items, or addUserTask(task: JumpListItem) to add tasks to the canonical "Tasks" section at the bottom.
4. Commit: Call commit() to finalize the changes. This returns a Result<Unit> which may indicate a recoverable error (e.g., if a category could not be appended due to access restrictions).

Note: When adding categories, ensure you do not re-add items that are present in getRemovedItems(), as they may not be re-added during the transaction.

For iOS applications using Kotlin/Native, you integrate Skiko by setting up a SkikoAppDelegate that manages a UIWindow. The root view controller should be a SkikoViewController containing a SkikoUIView which wraps a SkiaLayer. The SkiaLayer uses a SkikoRenderDelegate to handle drawing via the onRender callback.

fun main() {
    val args = emptyArray<String>()
    memScoped {
        val argc = args.size + 1
        val argv = (arrayOf("skikoApp") + args).map { it.cstr.ptr }.toCValues()
        autoreleasepool {
            UIApplicationMain(argc, argv, null, NSStringFromClass(SkikoAppDelegate))
        }
    }
}

class SkikoAppDelegate : UIResponder, UIApplicationDelegateProtocol {
    companion object : UIResponderMeta(), UIApplicationDelegateProtocolMeta

    @ObjCObjectBase.OverrideInit
    constructor() : super()

    private var _window: UIWindow? = null
    override fun window() = _window
    override fun setWindow(window: UIWindow?) {
        _window = window
    }

    override fun application(application: UIApplication, didFinishLaunchingWithOptions: Map<Any?, *>?): Boolean {
        window = UIWindow(frame = UIScreen.mainScreen.bounds)
        window!!.rootViewController = SkikoViewController(
            SkikoUIView(
                SkiaLayer().apply {
                    renderDelegate = SkiaLayerRenderDelegate(skiaLayer, object : SkikoRenderDelegate {
                      val paint = Paint().apply { color = Color.RED }
                      override fun onRender(canvas: Canvas, width: Int, height: Int, nanoTime: Long) {
                        canvas.clear(Color.CYAN)
                        val ts = nanoTime / 5_000_000
                        canvas.drawCircle( (ts % width).toFloat(), (ts % height).toFloat(), 20f, paint )
                      }
                    })
                }
            )
        )
        window!!.makeKeyAndVisible()
        return true
    }
}

On the JVM, you can use SkiaLayer to integrate Skia rendering into a Swing application. You must provide a SkiaLayerRenderDelegate that implements the SkikoRenderDelegate interface. The onRender method provides a Canvas for drawing, the current dimensions, and a nanoTime timestamp.

fun main() {
    val skiaLayer = SkiaLayer()
    skiaLayer.renderDelegate = SkiaLayerRenderDelegate(skiaLayer, object : SkikoRenderDelegate {
        val paint = Paint().apply {
            color = Color.RED
        }
        override fun onRender(canvas: Canvas, width: Int, height: Int, nanoTime: Long) {
            canvas.clear(Color.CYAN)
            val ts = nanoTime / 5_000_000
            canvas.drawCircle( (ts % width).toFloat(), (ts % height).toFloat(), 20f, paint )
        }
    })
    SwingUtilities.invokeLater {
        val window = JFrame("Skiko example").apply {
            defaultCloseOperation = WindowConstants.EXIT_ON_CLOSE
            preferredSize = Dimension(800, 600)
        }
        skiaLayer.attachTo(window.contentPane)
        skiaLayer.needRedraw()
        window.pack()
        window.isVisible = true
    }
}