Announcing LocalStack for Snowflake 1.0 Release

Introduction

Today, we’re excited to announce the release of LocalStack for Snowflake 1.0. This marks a significant milestone in our mission to transform how developers build, test, and iterate on Snowflake data pipelines by bringing the entire development process to your local environment. Our vision is to get the same level of developer productivity and control to the Snowflake ecosystem that LocalStack users have come to love for AWS, enabling a seamless inner development loop, minimising dependencies on shared environments, reducing costs, and accelerating your time to market.

Since our last update, we’ve focused on building a robust, feature-complete emulator that transforms the Snowflake development experience. LocalStack for Snowflake 1.0 represents a significant evolution across three critical areas: compatibility, extensibility, and parity. We’ve worked to significantly increase the breadth and depth of Snowflake features you can use, making it easier than ever to build and test sophisticated Snowflake data pipelines, while streamlining your development cycles and enabling easier collaboration within teams, and saving costs by running your data pipelines locally.

In this blog, we will look at what’s new in this 1.0 release, highlight new features & enhancements, and discuss how you can get the most out of them!

How to migrate?

We have many LocalStack for Snowflake 1.0 resources for our users. For those with an active LocalStack for Snowflake license, upgrade your setup to 1.0.0, by running the following commands.

docker pull localstack/snowflake:1.0.0
IMAGE_NAME=localstack/snowflake:1.0.0 localstack start

If you’re using LocalStack for Snowflake with Docker CLI or Docker Compose, you can pin the image version in your docker run command or Docker Compose file to 1.0.0.

If you don’t have a LocalStack for Snowflake license, sign up for the upcoming trial or contact sales for a demo.

What’s new in LocalStack for Snowflake 1.0?

This 1.0 release is a major step forward, packed with new features and enhancements that address key use cases and user feedback. Our goal is to empower you to develop faster and test more thoroughly, with support for the core Snowflake feature set, enhanced client compatibility, and tools that seamlessly integrate with your existing workflows.

Here are some of the highlights you can find in LocalStack for Snowflake 1.0:

• Polaris Catalog
• Native Apps
• Materialized Views
• Row Access Policies
• Storage Integrations
• Zero-Copy Cloning
• Transaction Management
• Java User-Defined Functions
• Multi-Account setups
• Passwordless Authentication using RSA Key-Pair
• LocalStack Initialization Hooks
• Snowflake User Interface on Web Application
• Support for several new SQL functions
• Improved parity with Snowflake
• Miscellaneous

Polaris Catalog

The Snowflake emulator now supports Polaris Catalog, an open-source, vendor-neutral catalog for Apache Iceberg tables. Polaris Catalog enables organizations to manage and access their Iceberg tables across various query engines, promoting interoperability and reducing vendor lock-in.

LocalStack maintains its own fork of the Apache Polaris image, available on Docker Hub: localstack/polaris.

To run the Polaris Catalog container locally, use the following configuration:

docker run -d --name polaris-test \
  -p 8181:8181 -p 8182:8182 \
  -e AWS_REGION=us-east-1 \
  -e AWS_ACCESS_KEY_ID=test \
  -e AWS_SECRET_ACCESS_KEY=test \
  -e AWS_ENDPOINT_URL=http://localhost:4566 \
  -e POLARIS_BOOTSTRAP_CREDENTIALS=default-realm,root,s3cr3t \
  -e polaris.realm-context.realms=default-realm \
  -e quarkus.otel.sdk.disabled=true \
  localstack/polaris:latest

Once started, the Polaris Catalog is accessible at http://localhost:8181.

The emulator supports CREATE CATALOG INTEGRATION for integrating with Polaris Catalog. With Polaris Catalog running locally, users can:

• Create S3 buckets to store Iceberg table data & metadata.
• Create external volumes that point to the S3 buckets.
• Establish a catalog integration with Polaris Catalog.
• Create Iceberg tables that utilize external volumes & catalog integration.
• Perform operations and verify that data/metadata files are written to S3.

Check out our documentation on getting started with Polaris Catalog.

Native Apps

The Snowflake emulator now offers foundational support for Native Apps, enabling developers to build, test, and deploy native applications, including those with Streamlit frontends, entirely within a local environment. The following operations are supported:

• CREATE APPLICATION PACKAGE
• ALTER APPLICATION PACKAGE
• DROP APPLICATION PACKAGE
• SHOW APPLICATION PACKAGES

To run a Snowflake Native App locally using the emulator, you can run the following commands (assuming the emulator is running and you have Snowflake CLI installed with a localstack connection):

git clone https://github.com/snowflakedb/native-apps-examples.git
cd native-apps-examples/tasks-streams
snow app run --connection localstack

You can run the Native App end-to-end on your local machine using LocalStack.

Check out our documentation on getting started with Native Apps.

Materialized Views

The Snowflake emulator in LocalStack now supports Materialized Views, allowing developers to create precomputed, persistent views. This mirrors Snowflake’s native functionality and enables accurate testing of materialized view logic and behavior in local development environments. The following operations are supported:

• CREATE MATERIALIZED VIEW
• ALTER MATERIALIZED VIEW
• DESCRIBE MATERIALIZED VIEW
• DROP MATERIALIZED VIEW
• SHOW MATERIALIZED VIEWS
• TRUNCATE MATERIALIZED VIEW

Check out our documentation on getting started with Materialized Views.

Row Access Policies

The Snowflake emulator now supports Row Access Policies, allowing developers to implement and test fine-grained, row-level access controls locally. These policies define conditions that determine which rows are visible to the querying user, emulating Snowflake’s native row-level security features.

Internally, the emulator uses PostgreSQL’s row-level security to enforce these rules during query execution, while distinguishing between superuser and standard user contexts to match Snowflake’s behavior more closely.

This is useful for developing and testing access control logic locally before applying it in production environments. Check out our documentation on getting started with Row Access Policies!

Storage Integrations

The Snowflake emulator now supports defining and managing Storage Integrations, enabling local testing of access to external storage systems like Amazon S3. These integrations emulate how Snowflake manages access to external cloud storage using IAM roles, giving you a realistic environment to develop and validate your data ingestion workflows. The following operations are supported:

• CREATE STORAGE INTEGRATION
• DESCRIBE STORAGE INTEGRATION
• DROP STORAGE INTEGRATION

Check out our documentation on getting started with the Storage Integrations.

Zero-Copy Cloning

The Snowflake emulator now supports zero-copy cloning, enabling developers to quickly create lightweight, instant local clones of tables or databases. This enables faster feedback loops in local development by letting you replicate data for testing or experimentation. The following cloning operations are supported:

• CREATE TABLE … CLONE
• CREATE DATABASE … CLONE

The current implementation focuses on cloning tables and databases. Support for cloning schemas, dynamic tables, and other object types like hybrid tables is not yet available. Check out our documentation on getting started with Zero-Copy Cloning.

Transaction Management

The Snowflake emulator now supports transactions, enabling developers to explicitly control transactional workflows using standard SQL commands. With this feature, you can emulate realistic database operations that require precise control over when changes are committed or rolled back. The following operations are supported:

• BEGIN
• COMMIT
• ROLLBACK
• CURRENT_TRANSACTION()
• SHOW TRANSACTIONS

Check out our documentation on getting started with Transaction Management.

Java User-Defined Functions

The Snowflake emulator in LocalStack now includes initial support for Java-based User-Defined Functions (UDFs), expanding its capabilities beyond Python and JavaScript. Developers can define and execute custom Java functions within the emulator to simulate Snowflake’s behavior more closely. Two modes are supported:

• Inline Java Code via the AS clause
• Staged JAR Files via the IMPORTS clause.

Support for additional data types and advanced scenarios is planned for future releases. Check out our documentation on getting started with User-Defined Functions!

Multi-Account setups

The Snowflake emulator now supports multi-account configurations, allowing you to simulate multiple Snowflake accounts in the same local environment. Developers can now create and manage isolated environments with identical resource names, such as databases and tables, across different account contexts, similar to real-world Snowflake deployments.

Behind the scenes, the emulator provisions a separate PostgreSQL backend for each account, ensuring complete data and namespace isolation. This is particularly useful for testing multi-tenant applications or workflows across dev, staging, and prod environments.

Passwordless Authentication using RSA Key-Pair

The Snowflake emulator now supports RSA key pair authentication, enabling passwordless logins for Snowflake users. This emulates Snowflake’s native key-based login mechanism, allowing you to configure a user with a public key and authenticate using the corresponding private key file.

To enable this, assign a public key to a user using the following SQL command within the emulator:

ALTER USER your_user_name SET RSA_PUBLIC_KEY='...';

Then, configure your Snowflake client to authenticate using the private key:

import snowflake.connector

conn = snowflake.connector.connect(
    user='your_user_name',
    account='your_account_identifier',
    private_key_file='/path/to/rsa_key.pem',
    # Include other parameters like warehouse, database, schema as needed
)

Note that, as of now, the Snowflake emulator does not validate the key contents - authentication via RSA keys is mocked and primarily intended for local testing.

Check out our documentation on getting started with various authentication mechanisms in the Snowflake emulator.

LocalStack Initialization Hooks

The Snowflake emulator now supports Initialization (or “Init”) Hooks, allowing developers to execute SQL scripts automatically during different phases of the container lifecycle. You can mount .sf.sql files into specific directories inside the container to run them at the BOOT, START, READY, or SHUTDOWN stages.

This enables teams to pre-seed databases, configure schemas, or run setup commands as part of the environment bootstrapping process.

To get started, simply create a SQL script like:

CREATE DATABASE foobar123;
CREATE DATABASE test123;
SHOW DATABASES;

Then, mount it into the ready.d hook directory when starting LocalStack:

IMAGE_NAME=localstack/snowflake \
DOCKER_FLAGS='-v /path/to/test.sf.sql:/etc/localstack/init/ready.d/test.sf.sql' \
localstack start

Once LocalStack starts and reaches the READY state, it will execute the script automatically and apply your specified SQL commands to the local Snowflake instance.

Check out our documentation on getting started with Initialization Hooks.

Snowflake User Interface on Web Application

The Snowflake emulator now includes a dedicated Snowflake tab in the LocalStack Web Application, providing an integrated interface to interact with your local Snowflake emulator. The UI enables you to execute SQL queries using a built-in Query Editor, inspect request and response logs, and optionally proxy queries to a real Snowflake environment.

To access the interface, start the Snowflake emulator and navigate to LocalStack Web Application in your browser.

The Worksheet tab allows you to run SQL statements and explore local databases and warehouses. The Logs tab shows detailed traces for all executed queries, including request/response headers and payloads. Additionally, the Proxy tab lets you securely forward your queries to a real Snowflake instance by entering scoped credentials.

Check out our documentation on getting started with the Snowflake User Interface.

Support for several new SQL functions

We have added support for several new SQL functions in LocalStack for Snowflake. The new functions include:

Improved parity with Snowflake

We have made several enhancements to LocalStack for Snowflake to improve compatibility with the Snowflake service. These improvements include:

• Iceberg table support was improved to include Iceberg metadata files using the PyIceberg library maintained by the Iceberg community.
• Added automatic conversion of strings to ARRAY and OBJECT types.
• Enhanced logic for timestamp assignments in MERGE INTO queries.
• Added support for lateral column references in SELECT statements.
• Enhanced parity for $N references in WHERE clauses.
• Enhanced support for CASE expressions in BEGIN..END blocks.
• Enhanced compatibility with Snowflake Go driver, JDBC driver & SnowSQL.
• Enhanced CRUD support for external volumes.
• Enhanced support for metadata columns in Parquet format.
• Enhanced decimal parity to assign proper byte length to values and treat scientific notation with the highest precision.
• The following SQL functions had their parity improved or support enhanced:
  • SHOW ROLES and USE ROLE
  • COUNT
  • MERGE INTO
  • COPY INTO (improved file-formats handling; added HEADER & FIELD_OPTIONALLY_ENCLOSED_BY support; parity improved for multiple-stage files)
  • SHOW COLUMNS & SHOW SCHEMAS
  • SHOW TABLES
  • DESCRIBE DATABASE
  • SHOW DYNAMIC TABLES
  • TO_TIMESTAMP (improved timestamp-string parsing)
  • TO_CHAR (enhanced date & number formatting)
  • OBJECT_CONSTRUCT_KEEP_NULL (enhanced to retain NULL values)
  • REGEXP_SUBSTR
  • EQUAL_NULL
  • CASE expressions in BEGIN…END blocks
  • CREATE MATERIALIZED VIEW queries

This also includes dozens of small compatibility fixes and quality‑of‑life improvements across COPY INTO, MERGE, transaction blocks, and identifier parsing to ensure compatibility & parity with Snowflake’s behavior.

Miscellaneous

The Snowflake emulator now also supports:

• Numeric paramstyle.
• TIMEZONE session parameter.
• AVRO file format handling in stages.
• Automatic conversion of strings to ARRAY and OBJECT types.
• Lateral column references in SELECT statements.
• NOT EQUAL operator in SQL queries.
• Prepared statements in the ODBC driver.
• Metadata columns in JSON format.
• Dropping multiple columns in a single ALTER statement.
• ZTSD compression in COPY INTO and SELECT FROM stage queries.
• Configurable default user and password using the environment variables: SF_DEFAULT_USER and SF_DEFAULT_PASSWORD.

Additionally, we’ve improved query performance by reusing PostgreSQL connections per session by ~37%. You can disable this by setting the configuration DB_CONNECTION_PER_SESSION to false.

Get started with LocalStack for Snowflake 1.0

LocalStack for Snowflake 1.0 brings the power of local cloud emulation to your fingertips, enabling faster iteration, robust testing, and significant cost savings. Here’s how to get started and take full advantage of this release:

• New to LocalStack? Our LocalStack for Snowflake trial is dropping soon. Sign up for immediate access once it’s ready by using this form, or request a demo from sales.
• See it in Action: Visit our Snowflake samples repository on GitHub to find various practical examples that demonstrate how to use various features.
• Deep Dive into Changes: For a granular look at every update, bug fix, and enhancement, consult our Snowflake changelog.
• Community Showcase: Join us at our upcoming virtual meetup where we’ll be demoing LocalStack for Snowflake 1.0 and answering your questions live!
• Get Support: If you have any questions or need help, please reach out to us on our Web Application chat or via email at support@localstack.cloud.
• Connect with Us: Your feedback is invaluable! Join our Community Slack to ask questions, share your experiences, report bugs, or suggest new features.

We are incredibly thankful to our dedicated community and users. Your suggestions, feedback, and bug reports through GitHub Issues and our Slack community have been instrumental in shaping this 1.0 release. It would not have been possible without your support, and we’re excited to see what you build with LocalStack for Snowflake!

Conclusion

LocalStack for Snowflake 1.0 release is a landmark moment for us and, we hope, for every developer working with Snowflake. This major milestone represents the culmination of our efforts to provide a truly local, high-fidelity environment that significantly reduces friction in your development and testing workflows. Now, all the capabilities in this release—from Polaris Catalog integration to local Native App deployment—are available to speed up development and improve quality without relying on live cloud resources.

With this release, we’ve laid a robust foundation - but we’re just getting started. Looking ahead, our ongoing focus for LocalStack for Snowflake will be on:

• Enhance core functionalities, such as implementing more comprehensive Role-Based Access Control (RBAC) beyond basic mocking.
• Expand cloning support to include schemas and ensure features like streams work seamlessly with views.
• Introduce support for Snowflake’s REST API endpoints for easier local resource management and integration with third-party tools.
• Explore integrations like connecting with AWS Kinesis Data Firehose and enabling Snowflake data sharing features locally.
• Support for additional Snowflake features, such as JavaScript procedures, Information Schema, Tabular SQL UDFs (UDTFs), and build more parity with Snowflake’s SQL dialect.

The journey to 1.0 has been fueled by the invaluable input from our community. We’re excited to see how LocalStack for Snowflake 1.0 transforms your development workflows and empowers you to build even more amazing data applications. Thank you for your continued support as we work together to redefine local cloud development.