> ## Documentation Index > Fetch the complete documentation index at: https://docs.powersync.com/llms.txt > Use this file to discover all available pages before exploring further. # Tauri SDK (alpha) > Use PowerSync in Tauri apps. The JavaScript part of the SDK is distributed via NPM The Rust part of the SDK is available via crates.io Refer to `packages/tauri` in the `powersync-js` repo on GitHub Full API reference for the SDK Gallery of example projects/demo apps built with Tauri and PowerSync Changelog for the SDK This SDK is currently in [**alpha**](/resources/feature-status), intended for external testing and public feedback. While it exposes the same stable JavaScript APIs as other PowerSync JavaScript SDKs, the underlying [Rust SDK](/client-sdks/reference/rust) and the IPC protocol between the JavaScript and Rust packages are subject to change. Expect breaking changes and instability as development continues. There are [known limitations](#limitations) currently. ### SDK Features * **Real-time streaming of database changes**: Changes made by one user are instantly streamed to all other users with access to that data. This keeps clients automatically in sync without manual polling or refresh logic. * **Direct access to a local SQLite database**: Data is stored locally, so apps can read and write instantly without network calls. This enables offline support and faster user interactions. * **Asynchronous background execution**: The SDK performs database operations in the background to avoid blocking the application’s main thread. This means that apps stay responsive, even during heavy data activity. * **Query subscriptions for live updates**: The SDK supports query subscriptions that automatically push real-time updates to client applications as data changes, keeping your UI reactive and up to date. * **Automatic schema management**: PowerSync syncs schemaless data and applies a client-defined schema using SQLite views. This architecture means that PowerSync SDKs can handle schema changes gracefully without requiring explicit migrations on the client-side. ## Installation Add the [PowerSync Tauri NPM package](https://www.npmjs.com/package/@powersync/tauri-plugin) to your project: ```bash theme={null} npm install @powersync/tauri-plugin ``` ```bash theme={null} yarn add @powersync/tauri-plugin ``` ```bash theme={null} pnpm install @powersync/tauri-plugin ``` Like all trusted PowerSync packages, the Tauri plugin is only available through the `@powersync/` scope on npm. The PowerSync Tauri plugin **cannot** be installed with the `tauri add` command. Additionally, add the Tauri plugin crate to your Rust app (in the `src-tauri` directory): ```bash theme={null} cargo add tauri-plugin-powersync ``` In your `lib.rs`, ensure the plugin is loaded: ```diff theme={null} pub fn run() { tauri::Builder::default() .invoke_handler(tauri::generate_handler![connect]) + .plugin(tauri_plugin_powersync::init()) .run(tauri::generate_context!()) .expect("error while running tauri application"); } ``` In `src-tauri/capabilities/default.json`, ensure `powersync:default` is listed under `permissions` to make PowerSync APIs available to JavaScript. ## Getting Started **Prerequisites**: To sync data between your client-side app and your backend source database, you must have completed the necessary setup for PowerSync, which includes connecting your source database to the PowerSync Service and deploying Sync Streams (or legacy Sync Rules) (steps 1-4 in the [Setup Guide](/intro/setup-guide)). ### 1. Define the Client-Side Schema This refers to the schema for the managed SQLite database exposed by the PowerSync Client SDKs, that your app can read from and write to. The schema is applied when the database is instantiated (as we'll show in the next step) — no migrations are required. **Generate schema automatically** In the [PowerSync Dashboard](https://dashboard.powersync.com/), select your project and instance and click the **Connect** button in the top bar to generate the client-side schema in your preferred language. The schema will be generated based off your Sync Streams/Rules. Similar functionality exists in the [CLI](/tools/cli). **Note:** The generated schema will not include an `id` column, as the client SDK automatically creates an `id` column of type `text`. Consequently, it is not necessary to specify an `id` column in your schema. For additional information on IDs, refer to [Client ID](/sync/advanced/client-id). The types available are `text`, `integer` and `real`. These should map directly to the values produced by your [Sync Streams](/sync/streams/overview) (or legacy [Sync Rules](/sync/rules/overview)). If a value doesn't match, it is cast automatically. For details on how backend source database types are mapped to the SQLite types, see [Types](/sync/types). The Tauri SDK inherits the same APIs from the JavaScript Web SDK via `@powersync/common`, with a few exceptions detailed below. See the [Web SDK schema definition section](/client-sdks/reference/javascript-web#1-define-the-client-side-schema) for more advanced examples. **Example**: ```js theme={null} // AppSchema.ts import { column, Schema, Table } from '@powersync/common'; const lists = new Table({ created_at: column.text, name: column.text, owner_id: column.text }); const todos = new Table( { list_id: column.text, created_at: column.text, completed_at: column.text, description: column.text, created_by: column.text, completed_by: column.text, completed: column.integer }, { indexes: { list: ['list_id'] } } ); export const AppSchema = new Schema({ todos, lists }); // For types export type Database = (typeof AppSchema)['types']; export type TodoRecord = Database['todos']; // OR: // export type Todo = RowType; export type ListRecord = Database['lists']; ``` **Note**: No need to declare a primary key `id` column, as PowerSync will automatically create this. ### 2. Instantiate the PowerSync Database Next, you need to instantiate the PowerSync database. PowerSync streams changes from your backend source database into the client-side SQLite database, based on your [Sync Streams](/sync/streams/overview) (or legacy [Sync Rules](/sync/rules/overview)). In your client-side app, you can read from and write to the local SQLite database, whether the user is online or offline. **Example**: ```js theme={null} import { PowerSyncTauriDatabase } from '@powersync/tauri-plugin'; import { appDataDir } from '@tauri-apps/api/path'; import { AppSchema } from './AppSchema'; export const db = new PowerSyncTauriDatabase({ // The schema you defined in the previous step schema: AppSchema, database: { // Filename for the SQLite database. dbFilename: 'powersync.db', // An optional directory to store the database file in. dbLocationAsync: appDataDir, } }); ``` Finally, instruct PowerSync to sync data from your backend. For Tauri apps, the sync client must be driven from Rust code. To do that, add a new Tauri command to your Rust application: ```Rust theme={null} use tauri_plugin_powersync::PowerSyncExt; #[tauri::command] async fn connect( app: AppHandle, handle: usize, ) -> tauri_plugin_powersync::Result<()> { let ps = app.powersync(); let database = ps.database_from_javascript_handle(handle)?; // MyBackendConnector is defined in the next step... let options = SyncOptions::new(MyRustConnector { db: database.clone(), }); database.connect(options).await; Ok(()) } ``` Ensure the command is registered by including it in the invoke handler with `tauri::generate_handler![connect]`. You can then invoke that command from your JavaScript code to connect: ```TypeScript theme={null} import { PowerSyncTauriDatabase } from '@powersync/tauri-plugin'; import { invoke } from '@tauri-apps/api/core'; async function connect(db: PowerSyncTauriDatabase) { await db.init(); const handle = db.rustHandle; await invoke('connect', { handle }); } ``` ### 3. Integrate with Your Backend The PowerSync backend connector provides the connection between your application backend and the PowerSync client-side managed SQLite database. It is used to: 1. Retrieve an auth token to connect to the PowerSync instance. 2. Upload client-side writes to your backend API. Any writes that are made to the SQLite database are placed into an upload queue by the PowerSync Client SDK and automatically uploaded to your app backend (where you apply those changes to the backend source database) when the user is connected. At the moment, backend connectors for the Tauri SDK must be implemented in Rust. This allows the connector to be used across multiple windows and even when no JavaScript is running. Please [let us know](/resources/contact-us) if you want to implement a backend connector in JavaScript. Accordingly, the connector must implement two methods: 1. `fetch_credentials` - This method is automatically invoked by the PowerSync Client SDK to obtain authentication credentials. The SDK caches credentials internally and only calls this method when needed (e.g. on initial connection or when the token is near expiry). See [When `fetchCredentials()` is Called](/configuration/app-backend/client-side-integration#when-fetchcredentials-is-called) for details, and [Authentication Setup](/configuration/auth/overview) for instructions on how the credentials should be generated. 2. `upload_data` - This method will be automatically invoked by the PowerSync Client SDK whenever it needs to upload client-side writes to your app's backend API. You need to implement how those writes are processed and uploaded in this method. See [When `uploadData()` is Called](/configuration/app-backend/client-side-integration#when-uploaddata-is-called) for details on triggers, throttling, and retry behavior, and [Writing Client Changes](/handling-writes/writing-client-changes) for considerations on the app backend implementation. **Example**: ```Rust theme={null} struct MyBackendConnector { db: PowerSyncDatabase, } #[async_trait] impl BackendConnector for MyBackendConnector { async fn fetch_credentials(&self) -> Result { // implement fetchCredentials to obtain the necessary credentials to connect to your backend // See an example implementation in https://github.com/powersync-ja/powersync-native/blob/508193b0822b8dad1a534a16462e2fcd36a9ac68/examples/egui_todolist/src/database.rs#L119-L133 Ok(PowerSyncCredentials { endpoint: "[Your PowerSync instance URL or self-hosted endpoint]".to_string(), // Use a development token (see Authentication Setup https://docs.powersync.com/configuration/auth/development-tokens) to get up and running quickly token: "An authentication token".to_string(), }) } async fn upload_data(&self) -> Result<(), PowerSyncError> { // Implement uploadData to send local changes to your backend service // You can omit this method if you only want to sync data from the server to the client // See an example implementation under Usage Examples (sub-page) // See https://docs.powersync.com/handling-writes/writing-client-changes for considerations. let mut local_writes = self.db.crud_transactions(); while let Some(tx) = local_writes.try_next().await? { todo!("Inspect tx.crud for local writes that need to be uploaded to your backend"); tx.complete().await?; } Ok(()) } } ``` ## Using PowerSync: CRUD functions Once the PowerSync instance is configured you can start using the SQLite DB functions. **All CRUD examples from the JavaScript Web SDK apply**: The Tauri SDK exposes the same JavaScript database API as the Web SDK. See the [JavaScript Web SDK CRUD functions section](/client-sdks/reference/javascript-web#using-powersync-crud-functions) for examples of `get`, `getAll`, `watch`, `execute`, `writeTransaction`, incremental watch updates, and differential results. The most commonly used CRUD functions to interact with your SQLite data are: * [PowerSyncDatabase.get](/client-sdks/reference/javascript-web#fetching-a-single-item) - get (SELECT) a single row from a table. * [PowerSyncDatabase.getAll](/client-sdks/reference/javascript-web#querying-items-powersync.getall) - get (SELECT) a set of rows from a table. * [PowerSyncDatabase.watch](/client-sdks/reference/javascript-web#watching-queries-powersync.watch) - execute a read query every time source tables are modified. * [PowerSyncDatabase.execute](/client-sdks/reference/javascript-web#mutations-powersync.execute) - execute a write (INSERT/UPDATE/DELETE) query. ### Fetching a Single Item The [get](https://powersync-ja.github.io/powersync-js/web-sdk/classes/PowerSyncDatabase#get) method executes a read-only (SELECT) query and returns a single result. It throws an exception if no result is found. Use [getOptional](https://powersync-ja.github.io/powersync-js/web-sdk/classes/PowerSyncDatabase#getoptional) to return a single optional result (returns `null` if no result is found). ```js theme={null} // Find a list item by ID export const findList = async (id) => { const result = await db.get('SELECT * FROM lists WHERE id = ?', [id]); return result; } ``` ### Querying Items (PowerSync.getAll) The [getAll](https://powersync-ja.github.io/powersync-js/web-sdk/classes/PowerSyncDatabase#getall) method returns a set of rows from a table. ```js theme={null} // Get all list IDs export const getLists = async () => { const results = await db.getAll('SELECT * FROM lists'); return results; } ``` ### Watching Queries (PowerSync.watch) The [watch](https://powersync-ja.github.io/powersync-js/web-sdk/classes/PowerSyncDatabase#watch) method executes a read query whenever a change to a dependent table is made. ```javascript theme={null} async function* pendingLists(): AsyncIterable { for await (const result of db.watch( `SELECT * FROM lists WHERE state = ?`, ['pending'] )) { yield result.rows?._array ?? []; } } ``` ```javascript theme={null} const pendingLists = (onResult: (lists: any[]) => void): void => { db.watch( 'SELECT * FROM lists WHERE state = ?', ['pending'], { onResult: (result: any) => { onResult(result.rows?._array ?? []); } } ); } ``` For advanced watch query features like incremental updates and differential results, see [Live Queries / Watch Queries](/client-sdks/watch-queries). ### Mutations (PowerSync.execute, PowerSync.writeTransaction) The [execute](https://powersync-ja.github.io/powersync-js/web-sdk/classes/PowerSyncDatabase#execute) method can be used for executing single SQLite write statements. ```js theme={null} // Delete a list item by ID export const deleteList = async (id) => { const result = await db.execute('DELETE FROM lists WHERE id = ?', [id]); return TodoList.fromRow(results); } // OR: using a transaction const deleteList = async (id) => { await db.writeTransaction(async (tx) => { // Delete associated todos await tx.execute(`DELETE FROM ${TODOS_TABLE} WHERE list_id = ?`, [id]); // Delete list record await tx.execute(`DELETE FROM ${LISTS_TABLE} WHERE id = ?`, [id]); }); }; ``` When using the default client-side [JSON-based view system](/architecture/client-architecture#client-side-schema-and-sqlite-database-structure), writes are applied to a view, with triggers writing to the underlying table. Because of this, `result.rowsAffected` from `db.execute()` can be `0` even when an `UPDATE` or `DELETE` succeeds. When you need to confirm whether a mutation changed any rows, add a `RETURNING` clause and check the returned rows: ```js theme={null} const result = await db.execute( 'UPDATE tasks SET deleted_at = ? WHERE id = ? AND deleted_at IS NULL RETURNING id', [now, id] ); const wasUpdated = (result.rows?.length ?? 0) > 0; ``` If you need direct table writes, use [raw tables](/client-sdks/advanced/raw-tables). ## Configure Logging The Rust SDK uses the `log` crate which can be enabled using the [Tauri logging plugin](https://v2.tauri.app/plugin/logging/). ## Sharing a Database with Rust Code A `PowerSyncTauriDatabase` instance can be shared with Rust code: 1. Call and await `.init()` on the database to ensure the database has been opened. 2. Use the `.rustHandle` getter, which returns a number representing the database instance. 3. This handle can now be passed as an argument to one of your Tauri commands. In Rust SDK, you can use `AppHandle::powersync()` and `PowerSync::database_from_javascript_handle` to inspect the database from Rust. See the [Rust SDK guide](/client-sdks/reference/rust) for more information. Connection locks and table updates are automatically shared between Rust and JavaScript code. ## Limitations * The Rust SDK, which is used to implement the Tauri plugin, has limited support for legacy Sync Rules: On `SyncStatus`, `lastSyncedAt`, `hasSynced` and `priorityStatusEntries` are not available. Use the status on individual Sync Streams through `SyncStatus.forStream` instead. * Connecting to the PowerSync Service is only possible from Rust. Calling `connect()` from JavaScript will throw. ## Additional Usage Examples For more usage examples including accessing connection status, monitoring sync progress, and waiting for initial sync, see the [Usage Examples](/client-sdks/usage-examples) page. ## ORM Support See [JavaScript ORM Support](/client-sdks/orms/js/overview) for details. ## Troubleshooting See [Troubleshooting](/debugging/troubleshooting) for pointers to debug common issues.