Skip to content
KNIME Documentation
Main Navigation Get startedBuildWork with KnimeAccount and adminRelease notesDeveloper tools
Community Hub
DevelopersKnime
Sidebar Navigation

Getting Started

Installation

User Guide

Release Notes

Install Extensions

Building Workflows

Components

Flow Control

Expressions

File Handling

Deployment

Integrated Deployment

Workflow Invocation

Best Practices

Advanced Features

AI Extension

Get Started

Build an Agent

Inject context with RAG

LLM Providers

Tutorials

Summarize product reviews

Product FAQ assistant

Restaurant agent

Your first local agent

Task extractor

Reporting

Kerberos

Extensions

Database

Overview

Tutorials

Read and filter data from a database

Write a transformed dataset to a database

Concepts

Ports and Sessions

Query Generation

Type Mapping

Deprecated Framework

Connecting

Connect: Dedicated Node

Connect: File-Based Database

Connect: Generic DB Connector

Register a JDBC Driver

Install Third-Party Driver Plug-in

Drivers on Hub and Server

Kerberos Constrained Delegation

Reading and Transforming

Read Data

Transform Data Visually

Run a Custom SQL Query

Parameterize a Query

Writing and Modifying

Insert, Update, or Merge

Delete Rows

Bulk Load Data

Create and Remove Tables

Use Transactions

Reference

Connector Node Settings

JDBC Driver Reference

Deprecated Node Mapping

Migrate Deprecated Workflows

Python

Overview

Tutorials

Python Scripting Quickstart

Data App Development Using Plotly

Data Processing

K-AI Scripting Assistant

Data Type Conversion

Batch Processing

Jupyter Integration

Environment Management

Pixi Configuration

Dependency Management

Environment Persistence

Channel Mirrors & Air-Gapped Setups

Conda Migration

Alternative Configurations

Conda and Miniforge Setup

Conda Environment Propagation

Manual Python Configuration

Legacy Node Migration

Concepts

Pixi Backend Architecture

Storage Logic

Python Environments on Executors

Reference

Python Scripting API

Bundled Packages

Executor and Hub Configuration

Troubleshooting Guide

API Reference

Inputs and outputs

Classes

Views

Utility functions

R

Deep Learning

Snowflake

Google Cloud

Azure

AWS

Big Data

Big Data Admin

Big Data Secured Cluster

Databricks

Microsoft Fabric

Power BI

Tableau

Report Designer

H2O

Changelogs

Version 5.12

Version 5.11

Version 5.10

Version 5.9

Version 5.8

Version 5.7

Version 5.6

Version 5.5

Version 5.3

Extensions

The Pixi Backend ​

The modern Python integration in KNIME is powered by Pixi, a package management tool built on the Conda ecosystem.

Key Benefits of the Pixi Backend ​

  • Cross-platform by design: Environments are resolved for all target operating systems (Windows, Linux, macOS) simultaneously.
  • Fully reproducible: The exact state of the environment is saved as a pixi.lock file, guaranteeing identical package versions everywhere.
  • Significantly faster: Both environment resolution and node configuration are much faster. The node dialog opens instantly, eliminating the 2-minute wait times associated with legacy Conda nodes.
  • Zero setup required: Pixi comes pre-installed and encapsulated within KNIME. No manual Conda installation or user configuration is needed.
  • In-workflow definition: You can define and edit the environment directly inside the KNIME workflow. In contrast, the legacy Conda Environment Propagation (CEP) node could only read pre-created local environments.
  • Browser-ready modern UI: The node's modern interface is designed to work seamlessly in the browser for future cloud-based editing features.

When to use which system ​

Choosing between the modern Pixi-based nodes and legacy Conda-based setups depends on your deployment needs and environment access.

Use the Python Environment Provider (Modern/Pixi) if: ​

  • You are deploying to the Hub: This is the recommended way to guarantee that an environment built on Windows will resolve and install correctly on a Linux-based Hub executor.
  • You want "Zero Setup": Use this to avoid the manual installation and configuration of Conda or Miniforge in the KNIME Preferences.
  • You need specific versions per workflow: Since the environment is defined at the node level, you can have different workflows using conflicting library versions without interference.
  • You are preparing for cloud editing: While browser-based editing is a future feature, using these nodes now ensures your workflows will be compatible once released.

Use Conda / Manual Configuration (Legacy) if: ​

  • You have a pre-existing, complex local environment: If you have a large, curated Conda environment on your local machine that is difficult to replicate via a simple specification.
  • You have restricted internet access: If your security environment blocks Pixi from reaching external repositories and you haven't configured a local mirror or a Conda fallback.
  • You need a specific system-level Python: If your code must interact with a specific Python binary installed at the OS level (e.g., for hardware-specific drivers).

Key Concepts ​

Port Objects vs. Flow Variables ​

The legacy system passed environment information through Flow Variables (red connections). The modern integration uses Port Objects (square connections).

Environment Locking ​

The "Lock Package Versions" feature in the PEP node performs a compatibility check across all target platforms simultaneously. It generates a deterministic lock-file (pixi.lock) that guarantees every executor, whether on a laptop or a Hub instance, installs the exact same version of every library.

Pager
Previous pageLegacy Node Migration
Next pageStorage Logic