Application Packages in Declarative Sharing in the Native Application Framework

As a provider, you create an application package to bundle your data content and notebooks into a Declarative Native App. This topic explains what an application package is and describes the high-level steps to create one, from creating the initial package to adding your manifest and notebook files.

The Application Package and the Live Version

The application package is a container for all the files that make up the app, including the manifest file and any Snowflake Notebooks. When you create an application package, a live (staged) version of the application package is also created. The live version is a development workspace where you can add or update files, such as the manifest file and notebook files, and preview and test the experience before publishing.

Once you’re satisfied with the live version of the app, you can commit the live version to create a new immutable version of the application package, that you can then publish.

Using the live version for development simplifies version management by maintaining a single immutable version of the application package that is ready to be published, and a single live version for development. The Snowflake Native App Framework automatically manages the versioning of the application package, so you don’t need to manually track version numbers.

The Snowflake Native App Framework maintains a live version for any application package automatically. Even if you remove the live version, a new live version is created automatically from the last committed version of the application package.

Create an application package

Providers develop and test an application package. An application package includes files necessary to share the data in the app, and defines how data can be accessed by consumers.

The process involves the following steps:

  1. Create an application package file (first time only): creates an application package file that will later be published. This also creates the live version of the application package.

  2. Add content to the application package:

    1. Create or update a manifest file: This file describes the application package and its contents.

    2. Download notebook files. If notebooks are to be included, download a copy to be included in the application package.

    3. Add the files to the live version of the application package.

  3. Build the application package: allows you to verify that the manifest file is valid and that all links in the manifest file are correct.

  4. Test the application. Install the app and try it out. Make changes, and rebuild.

  5. Commit the application package: creates a new immutable version of the app that can be published.

  6. Release the application package. With a released package, you can create a new listing, either privately or publicly on the Snowflake Marketplace.

This process is described in the Tutorial: Getting started with Declarative Native Apps. This section includes additional details of options available at the different stages of development.

Diagram showing the steps of creating an application package: Add live package, build, commit, and release. The diagram also shows the optional steps to skip ahead to build, commit, and release a live version all at once.

Create a new application package

Create an Declarative Native App package using the command: CREATE APPLICATION PACKAGE … TYPE=DATA:

CREATE APPLICATION PACKAGE DECL_SHARE_APP_PKG TYPE = DATA;
Copy

The new empty application package is created. This also creates a live version of the application package that you can edit.

Add content to the application package

Include the following contents in the application package:

  • A manifest file (required): a text-based file that defines the app’s structure.

  • Snowflake Notebook files (optional): a text-based file that can act as a front end to the consumer experience, referencing the shared views and tables. They can also include code, reference visualizations, and include logic to help present the data.

App package components diagram

Create or update a manifest file

Providers create or update a manifest file, which describes the application package and its shared content, for example, notebooks, tables, and views. It defines other metadata, such as app roles included with the app.

The manifest file must be named manifest.yml, and must be added to the root level of the application package.

For more information, see Declarative Native App manifest reference. The associated Tutorial: Getting started with Declarative Native Apps includes an example manifest file.

Get notebook files

If Snowflake Notebooks are to be included in the app, download a copy of the notebook file so you can include it in the application package.

From Snowsight:

  1. In the upper-left corner of Snowsight choose + » Notebook. Find the notebook you want to download.

  2. On the left pane, next to your notebook, select … » Download.

The file is downloaded to your local machine, as a file named <notebook_name>.ipynb.

Add the files to the live version

Add and access files using SQL commands from Snowflake CLI, using the snow://package/<package_name>/versions/LIVE/ URL scheme. Examples:

  • Add a file to the application package:

    snow sql -q "PUT file:////Users/test_user/Documents/manifest.yml  snow://package/DECL_SHARE_APP_PKG/versions/LIVE/ OVERWRITE=TRUE AUTO_COMPRESS=false;"

snow sql -q "PUT file:////Users/test_user/Documents/NOTEBOOK.ipynb  snow://package/DECL_SHARE_APP_PKG/versions/LIVE/ OVERWRITE=TRUE AUTO_COMPRESS=false;"
    Copy

  • Verify the files are in the application package:

    snow sql -q "LIST snow://package/DECL_SHARE_APP_PKG/versions/LIVE"
    Copy
    +--------------------------------------------------------------------------------+
| name                          | size | md5     | last_modified                 |
|-------------------------------+------+---------+-------------------------------|
| /versions/live/manifest.yml   | 304  | 843a... | Wed, 23 Jul 2025 08:27:26 GMT |
| /versions/live/NOTEBOOK.ipynb | 832  | b014... | Wed, 23 Jul 2025 04:32:22 GMT |
+--------------------------------------------------------------------------------+

  • Download a file from the application package:

    snow sql -q "GET snow://package/<package_name>/versions/LIVE/manifest.yml file://manifest.yml"
    Copy

  • Remove content from the application package:

    snow sql -q "RM snow://package/<package_name>/versions/LIVE/manifest.yml"
    Copy

Build the application package

Build a testable version of the app (and verify that the manifest file is valid and all links work) with the command: ALTER APPLICATION PACKAGE … BUILD.

ALTER APPLICATION PACKAGE DECL_SHARE_APP_PKG BUILD;
Copy

If there are any errors in the manifest file, the build fails and gives information on how to fix the error. Correct those errors and rebuild the application package.

The built app remains in the live state, and you can continue to make changes to the application package.

Skip ahead!

For updates that don’t require further testing, you can skip ahead by building, committing, and releasing an application package all at once using the ALTER APPLICATION PACKAGE … RELEASE LIVE VERSION command.

ALTER APPLICATION PACKAGE DECL_SHARE_APP_PKG RELEASE LIVE VERSION;
Copy

Test the application

After building the application package, providers can perform basic tests from the live environment.

Install the app from an application package using the command: CREATE APPLICATION … FROM APPLICATION PACKAGE. For example:

CREATE APPLICATION DECL_SHARE_APP FROM APPLICATION PACKAGE DECL_SHARE_APP_PKG
Copy

Update the files in the application package as needed, and then see if it worked by using the command: ALTER APPLICATION PACKAGE … UPGRADE USING VERSION LIVE.

ALTER APPLICATION PACKAGE DECL_SHARE_APP_PKG UPGRADE USING VERSION LIVE;
Copy

To test some features, such as app roles, you must first release a new version of the application package, and then test using a separate consumer account. For more information, see Install a Declarative Native App and Access content in a Declarative Native App.

Optional: Reset edits on a live version

If the edits made to the live version of the application package are no longer needed, you can reset the application package to the state before the edits were made with the command: ALTER APPLICATION PACKAGE … ABORT LIVE VERSION

ALTER APPLICATION PACKAGE <package_name> ABORT LIVE VERSION;
Copy

When you use the preceding command to remove the current live version, a new live version is created with the same contents as the last committed version of the application package. The live version is reset to the last committed version, and all changes made to the live version are discarded.

Commit the application package

Providers build a new immutable version of the application that cannot be edited, and is ready to be published.

Use the ALTER APPLICATION PACKAGE command:

ALTER APPLICATION PACKAGE <package_name> COMMIT;
Copy

The live version of the application package is removed. A new live version of the application package is created from the new committed version for further development.

Release the application package

Release the application package with either the ALTER APPLICATION PACKAGE … RELEASE or ALTER APPLICATION PACKAGE … RELEASE LIVE VERSION command:

  • Release a committed application package:

    ALTER APPLICATION PACKAGE <package_name> RELEASE;
    Copy

  • Build, commit, and release a live version of the application package:

    ALTER APPLICATION PACKAGE <package_name> RELEASE LIVE VERSION;
    Copy

Releasing the application package does the following:

  • Makes a committed app ready to be shared with consumers.

  • If the provider has already shared the app with consumers, the new version is automatically available to those consumers.

  • If there’s already a live version of the app on the Snowflake Marketplace, the new version is automatically available to consumers who have installed the app.

After you release the application package, you can create a new listing for the app, either privately or publicly on the Snowflake Marketplace. For more information, see Creating a Listing using Declarative Sharing.

Language: English