Swiftpack.co - swiftwasm/JavaScriptKit as Swift Package

Swiftpack.co is a collection of thousands of indexed Swift packages. Search packages.
See all packages published by swiftwasm.
swiftwasm/JavaScriptKit 0.15.0
Swift framework to interact with JavaScript through WebAssembly.
⭐️ 481
🕓 11 weeks ago
.package(url: "https://github.com/swiftwasm/JavaScriptKit.git", from: "0.15.0")


Run unit tests

Swift framework to interact with JavaScript through WebAssembly.

Getting started

This JavaScript code

const alert = window.alert;
const document = window.document;

const divElement = document.createElement("div");
divElement.innerText = "Hello, world";
const body = document.body;

const pet = {
  age: 3,
  owner: {
    name: "Mike",

alert("JavaScript is running on browser!");

Can be written in Swift using JavaScriptKit

import JavaScriptKit

let document = JSObject.global.document

var divElement = document.createElement("div")
divElement.innerText = "Hello, world"
_ = document.body.appendChild(divElement)

struct Owner: Codable {
  let name: String

struct Pet: Codable {
  let age: Int
  let owner: Owner

let jsPet = JSObject.global.pet
let swiftPet: Pet = try JSValueDecoder().decode(from: jsPet)

_ = JSObject.global.alert!("Swift is running in the browser!")


Starting with SwiftWasm 5.5 you can use async/await with JSPromise objects. This requires a few additional steps though (you can skip these steps if your app depends on Tokamak):

  1. Make sure that your target depends on JavaScriptEventLoop in your Packages.swift:
    name: "JavaScriptKitExample",
    dependencies: [
        .product(name: "JavaScriptEventLoop", package: "JavaScriptKit")
  1. Add an explicit import in the code that executes *before you start using await and/or Task APIs (most likely in main.swift):
import JavaScriptEventLoop
  1. Run this function *before you start using await and/or Task APIs (again, most likely in main.swift):

Then you can await on the value property of JSPromise instances, like in the example below:

import JavaScriptKit
import JavaScriptEventLoop

let alert = JSObject.global.alert.function!
let document = JSObject.global.document

private let jsFetch = JSObject.global.fetch.function!
func fetch(_ url: String) -> JSPromise {


struct Response: Decodable {
    let uuid: String

var asyncButtonElement = document.createElement("button")
asyncButtonElement.innerText = "Fetch UUID demo"
asyncButtonElement.onclick = .object(JSClosure { _ in
    Task {
        do {
            let response = try await fetch("https://httpbin.org/uuid").value
            let json = try await JSPromise(response.json().object!)!.value
            let parsedResponse = try JSValueDecoder().decode(Response.self, from: json)
        } catch {

    return .undefined

_ = document.body.appendChild(asyncButtonElement)


For developers

  • macOS 11 and Xcode 13.2 or later versions, which support Swift Concurrency back-deployment. To use earlier versions of Xcode on macOS 11 you'll have to add .unsafeFlags(["-Xfrontend", "-disable-availability-checking"]) in Package.swift manifest of your package that depends on JavaScriptKit. You can also use Xcode 13.0 and 13.1 on macOS Monterey, since this OS does not need back-deployment.
  • Swift 5.5 or later and Ubuntu 18.04 if you'd like to use Linux. Other Linux distributions are currently not supported.

For users of apps depending on JavaScriptKit

Any recent browser that supports WebAssembly and required JavaScript features should work, which currently includes:

  • Edge 84+
  • Firefox 79+
  • Chrome 84+
  • Desktop Safari 14.1+
  • Mobile Safari 14.8+

If you need to support older browser versions, you'll have to build with the JAVASCRIPTKIT_WITHOUT_WEAKREFS flag, passing -Xswiftc -DJAVASCRIPTKIT_WITHOUT_WEAKREFS flags when compiling. This should lower browser requirements to these versions:

  • Edge 16+
  • Firefox 61+
  • Chrome 66+
  • (Mobile) Safari 12+

Not all of these versions are tested on regular basis though, compatibility reports are very welcome!

Usage in a browser application

The easiest way to get started with JavaScriptKit in your browser app is with the carton bundler.

As a part of these steps you'll install carton via Homebrew on macOS (you can also use the ghcr.io/swiftwasm/carton Docker image if you prefer to run the build steps on Linux). Assuming you already have Homebrew installed, you can create a new app that uses JavaScriptKit by following these steps:

  1. Install carton:
brew install swiftwasm/tap/carton

If you had carton installed before this, make sure you have version 0.6.1 or greater:

carton --version
  1. Create a directory for your project and make it current:
mkdir SwiftWasmApp && cd SwiftWasmApp
  1. Initialize the project from a template with carton:
carton init --template basic
  1. Build the project and start the development server, carton dev can be kept running during development:
carton dev
  1. Open in your browser and a developer console within it. You'll see Hello, world! output in the console. You can edit the app source code in your favorite editor and save it, carton will immediately rebuild the app and reload all browser tabs that have the app open.

You can also build your project with webpack.js and a manually installed SwiftWasm toolchain. Please see the following sections and the Example directory for more information in this more advanced use case.

Manual toolchain installation

This library only supports swiftwasm/swift toolchain distribution. The toolchain can be installed via swiftenv, in the same way as the official Swift nightly toolchain.

You have to install the toolchain manually when working on the source code of JavaScriptKit itself, especially if you change anything in the JavaScript runtime parts. This is because the runtime parts are embedded in carton and currently can't be replaced dynamically with the JavaScript code you've updated locally.

Just pass a toolchain archive URL for the latest SwiftWasm 5.6 release appropriate for your platform:

$ swiftenv install "https://github.com/swiftwasm/swift/releases/download/swift-wasm-5.6.0-RELEASE/swift-wasm-5.6.0-RELEASE-macos_$(uname -m).pkg"

You can also use the install-toolchain.sh helper script that uses a hardcoded toolchain snapshot:

$ ./scripts/install-toolchain.sh
$ swift --version
Swift version 5.6 (swiftlang-5.6.0)
Target: arm64-apple-darwin20.6.0


Stars: 481
Last commit: 1 week ago
jonrohan Something's broken? Yell at me @ptrpavlik. Praise and feedback (and money) is also welcome.

Related Packages

Release Notes

11 weeks ago

This is a major release that adds new features and fixes issues. Specifically:

  • BigInt and BigInt-based JSTypedArray types are now supported. Now, when passing Int64 values from Swift, they will be mapped to BigInt values on the JavaScript side.
  • The constructor property on JSBridgedClass is now an Optional, which allows bridging JavaScript classes that aren't available in every browser or environment.
  • JavaScriptKit runtime files are now supplied as SwiftPM resources. This allows us to resolve a long-standing issue in carton that could lead to a version mismatch between JavaScriptKit dependency in Package.swift or Package.resolved and carton’s bundled JavaScriptKit runtime version.
  • The JSSymbol type has been added, enabling support for JavaScript Symbol values, including accessing Symbol-keyed properties on objects.

Source breaking changes

UInt64.jsValue and Int64.jsValue, which are a part of JavaScriptKit module, have been moved into JavaScriptBigIntSupport module since their implementation changed to require JS-BigInt-integration to avoid implicit casts from 64-bit integer to JS number type.

If you want to keep the behavior so far, please cast the 64-bit integer values to Double.

Merged pull requests:

  • Improve JSKit diagnostics for use-after-free of JSClosure (#195) via @kateinoigakukun
  • Gracefully handle unavailable JSBridgedClass (#190) via @MaxDesiatov
  • Supply JSKit runtime in SwiftPM resources (#193) via @MaxDesiatov
  • Test with Node.js's WASI implementation (#192) via @kateinoigakukun
  • Add support for BigInts and BigInt-based TypedArrays (#184) via @j-f1
  • Update toolchain references to 5.6.0 in README.md (#189) via @MaxDesiatov
  • Bump async from 2.6.3 to 2.6.4 in /Example (#188) via @dependabot
  • Remove outdated BigInt support FIXME from JSTypedArray (#187) via @MaxDesiatov
  • Cleanup & improvements to perf-tester (#186) via @j-f1
  • Re-add support for Symbol objects via JSSymbol (#183) via @j-f1
  • Fix JSValueDecoder (#185) via @j-f1
  • Fix deprecation warning in JSFunction.swift (#182) via @MaxDesiatov

Swiftpack is being maintained by Petr Pavlik | @ptrpavlik | @swiftpackco | API | Analytics