The KNIME runtime options

KNIME's runtime behavior can be configured in various ways by passing options on the command line during startup. Since KNIME is based on Eclipse, all Eclipse runtime options also apply to KNIME. KNIME also adds additional options, which are described below

Command line arguments

Listed below are the command line arguments processed by KNIME. They can either be specified permanently in the knime.ini in the root of the KNIME installation, or be passed to the knime executable. Please note that command line arguments must be specified before the system properties (see below) i.e. before the -vmargs parameter.
Note that headless KNIME applications, such as the batch executor, offer quite a few command line arguments. They are not described here but are printed if you call the application without any arguments.

-checkForUpdates
If this arguments is used, KNIME automatically checks for updates during startup. If new versions of installed features are found, the user will be prompted to install them. A restart is required after updates have been installed.

Java system properties

Listed below are the Java system properties with which KNIME's behavior can be changed. They can either be specified permanently in the knime.ini in the root of the KNIME installation, or be passed to the knime executable. Please note that system properties must be specified after the -vmargs parameter. The required format is -DpropName=propValue .

General properties

knime.expert.mode=(true|false)
Enables the expert mode, which shows nodes and settings in node dialogs that are for experienced users who know what they are doing.
org.knime.core.maxThreads=<number>
Sets the maximum number of threads that KNIME is using for executing nodes. By default this number is 1.5 times the number of cores. This property overrides the value from the KNIME preference page.
knime.tmpdir=<directory>
Sets the default directory for temporary files KNIME files (such as data files). This property overrides the value from the preference pages and is by default the same as the java.io.tmpdir .
knime.synchronous.io=(true|false)
Can be used to disable the asynchronous writing of KNIME tables. By default, each table container writing to disk performs the write operation in a dedicated (potentially re-used) thread. Setting this field to true will instruct KNIME to always write synchronously, which in some cases may be slower.
knime.async.io.cachesize=<number>
Sets the size of the write cache for asynchronous table writing. It specifies the size of a temporary buffer for data rows that is used during table creating. Once this buffer is full (or there are no more rows to write), this buffer is handed over to the writing routines to write the data output stream. The larger the buffer, the smaller the synchronization overhead but the larger the memory requirements.
The default value is 10. This property has no effect if tables are written synchronously (see above).
knime.compress.io=(true|false)
Enables/disables table stream compression. Compression results in smaller temp-file sizes but also (sometimes significant) longer runtime. The default is true .
Warning: Changing this property will result in KNIME not being able to read workflows written previously (with a different compression property).
knime.disable.rowid.duplicatecheck=(true|false)
Enables/disables row ID duplicate checks on tables. Tables in KNIME are supposed to have unique IDs, whereby the uniqueness is asserted using a duplicate checker. This property will disable this check.
Warning: This property should not be changed by the user.
knime.domain.valuecount=<number>
The number of nominal values kept in the domain when adding rows to a table. This is only the default and may be overruled by individual node implementations. If no value is specified a default of 60 will be used.
knime.disable.vmfilelock=(true|false)
Enables/disables workflow locks. As of KNIME 2.4 workflows will be locked when opened; this property will disable the locking (allowing multiple instances to have the same workflow open).
Warning: This property should not be changed by the user.
knime.enable.fastload=(true|false)
Enables/disables loading the node repository asynchronously. By default, the node repository loads completely before the GUI is shown. If this flag is set to true , it will load the entire repository in the background while the GUI is already there is usable.
This flag only affects the KNIME client.
knime.database.timeout=<number>
Sets the timeout in seconds trying to establish a connection to a database. The default value is 15 seconds.
knime.database.fetchsize=<number>
Sets the fetch size for retrieving data from a database. The default value depends on the used JDBC driver.
knime.database.batch_write_size=<number>
Sets the batch write size for writing data rows into a database. The default value is 1, that is one row at a time.
knime.database.enable.concurrency=<boolean>
Used to switch on/off the database connection access (applies only for the same database connection). Default is true, that is all database accesses are synchronized based on single connection; false means off, that is, the access is not synchronized and may lead to database errors.
knime.logfile.maxsize=<number>[mk]
Allows one to change the maximum log file size (default is 10 MB). Values must be integer, possibly succeeded by "m" or "k" to denote that the given value is in mega or kilo byte.
knime.repository.non-instant-search=(true|false)
Allows to disable the live update in the node repository search.
knime.macosx.dialogworkaround=(true|false)
Allows to disable the workaround for freezes when opening node dialogs under MacOSX.
knime.data.bitvector.maxDisplayBits=<number>
Sets the maximum number of bits that are display in string representations of bit vectors.

Plug-in dependent properties

These properties only affect some plug-ins and are only applicable if they are installed.

org.knime.cmlminblobsize=<number>[mMkK]
Allows to change the minimum size in bytes (or kilobyte or megabytes) a CML molecule must have before it is stored in a blob cell. Otherwise it is stored inline. The latter is a bit faster but needs more memory. The default is 8kB.
org.knime.ctabminblobsize=<number>[mMkK]
Allows to change the minimum size in bytes (or kilobyte or megabytes) a Ctab molecule must have before it is stored in a blob cell. Otherwise it is stored inline. The latter is a bit faster but needs more memory. The default is 8kB.
org.knime.mol2minblobsize=<number>[mMkK]
Allows to change the minimum size in bytes (or kilobyte or megabytes) a Mol2 molecule must have before it is stored in a blob cell. Otherwise it is stored inline. The latter is a bit faster but needs more memory. The default is 8kB.
org.knime.molminblobsize=<number>[mMkK]
Allows to change the minimum size in bytes (or kilobyte or megabytes) a Mol molecule must have before it is stored in a blob cell. Otherwise it is stored inline. The latter is a bit faster but needs more memory. The default is 8kB.
org.knime.rxnminblobsize=<number>[mMkK]
Allows to change the minimum size in bytes (or kilobyte or megabytes) a Rxn molecule must have before it is stored in a blob cell. Otherwise it is stored inline. The latter is a bit faster but needs more memory. The default is 8kB.
org.knime.sdfminblobsize=<number>[mMkK]
Allows to change the minimum size in bytes (or kilobyte or megabytes) a SDF molecule must have before it is stored in a blob cell. Otherwise it is stored inline. The latter is a bit faster but needs more memory. The default is 8kB.

Properties for KNIME.com extensions

com.knime.licensedir=<directory>
Allows to change the location of the license directory (default is the installation directory).