diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
index 232518cda..dd48b739f 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/CodeWithConverter.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.codeGen
 
-public typealias Code = String
-public typealias VariableName = String
+import org.jetbrains.kotlinx.jupyter.api.Code
+import org.jetbrains.kotlinx.jupyter.api.VariableName
 
 /**
  * Class representing generated code declarations for a [Marker].
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
index 01f47fcbb..63ceb4ffd 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/ReplCodeGenerator.kt
@@ -2,9 +2,9 @@ package org.jetbrains.dataframe.impl.codeGen
 
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
-import org.jetbrains.kotlinx.dataframe.codeGen.Code
 import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
 import org.jetbrains.kotlinx.dataframe.impl.codeGen.ReplCodeGeneratorImpl
+import org.jetbrains.kotlinx.jupyter.api.Code
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
index 0a0aca8ef..dc1d94f6a 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/CodeGeneratorImpl.kt
@@ -19,7 +19,6 @@ import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.api.ColumnSelectionDsl
 import org.jetbrains.kotlinx.dataframe.api.DataSchemaEnum
 import org.jetbrains.kotlinx.dataframe.codeGen.BaseField
-import org.jetbrains.kotlinx.dataframe.codeGen.Code
 import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
 import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
 import org.jetbrains.kotlinx.dataframe.codeGen.ExtensionsCodeGenerator
@@ -34,6 +33,7 @@ import org.jetbrains.kotlinx.dataframe.codeGen.toNullable
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.impl.toSnakeCase
 import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
 
 private fun renderNullability(nullable: Boolean) = if (nullable) "?" else ""
 
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
index aa64903c5..763ac1c87 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/ReplCodeGeneratorImpl.kt
@@ -9,12 +9,12 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
 import org.jetbrains.kotlinx.dataframe.api.schema
-import org.jetbrains.kotlinx.dataframe.codeGen.Code
 import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
 import org.jetbrains.kotlinx.dataframe.codeGen.Marker
 import org.jetbrains.kotlinx.dataframe.codeGen.MarkerVisibility
 import org.jetbrains.kotlinx.dataframe.codeGen.MarkersExtractor
 import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
index 026cb3df1..b5ed79216 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/codeGen/SchemaReader.kt
@@ -4,7 +4,6 @@ import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.schema
-import org.jetbrains.kotlinx.dataframe.codeGen.Code
 import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
 import org.jetbrains.kotlinx.dataframe.io.SupportedCodeGenerationFormat
 import org.jetbrains.kotlinx.dataframe.io.SupportedDataFrameFormat
@@ -13,6 +12,7 @@ import org.jetbrains.kotlinx.dataframe.io.guessFormat
 import org.jetbrains.kotlinx.dataframe.io.read
 import org.jetbrains.kotlinx.dataframe.io.readCodeForGeneration
 import org.jetbrains.kotlinx.dataframe.schema.DataFrameSchema
+import org.jetbrains.kotlinx.jupyter.api.Code
 import java.net.URL
 
 /**
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
index 2250c9134..428254dcc 100644
--- a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/guess.kt
@@ -11,8 +11,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.ImportDataSchema
 import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
 import org.jetbrains.kotlinx.dataframe.annotations.OptInRefine
 import org.jetbrains.kotlinx.dataframe.api.single
-import org.jetbrains.kotlinx.dataframe.codeGen.Code
 import org.jetbrains.kotlinx.dataframe.codeGen.DefaultReadDfMethod
+import org.jetbrains.kotlinx.jupyter.api.Code
 import java.io.BufferedInputStream
 import java.io.File
 import java.io.FileNotFoundException
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
new file mode 100644
index 000000000..af4ebd902
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/Integration.kt
@@ -0,0 +1,338 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.dataframe.impl.codeGen.CodeGenerator
+import org.jetbrains.dataframe.impl.codeGen.ReplCodeGenerator
+import org.jetbrains.kotlinx.dataframe.AnyCol
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.DataRow
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.Convert
+import org.jetbrains.kotlinx.dataframe.api.FormatClause
+import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
+import org.jetbrains.kotlinx.dataframe.api.Gather
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
+import org.jetbrains.kotlinx.dataframe.api.GroupClause
+import org.jetbrains.kotlinx.dataframe.api.InsertClause
+import org.jetbrains.kotlinx.dataframe.api.Merge
+import org.jetbrains.kotlinx.dataframe.api.MoveClause
+import org.jetbrains.kotlinx.dataframe.api.Pivot
+import org.jetbrains.kotlinx.dataframe.api.PivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedGroupBy
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivot
+import org.jetbrains.kotlinx.dataframe.api.ReducedPivotGroupBy
+import org.jetbrains.kotlinx.dataframe.api.RenameClause
+import org.jetbrains.kotlinx.dataframe.api.ReplaceClause
+import org.jetbrains.kotlinx.dataframe.api.Split
+import org.jetbrains.kotlinx.dataframe.api.SplitWithTransform
+import org.jetbrains.kotlinx.dataframe.api.Update
+import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.asDataFrame
+import org.jetbrains.kotlinx.dataframe.api.columnsCount
+import org.jetbrains.kotlinx.dataframe.api.isColumnGroup
+import org.jetbrains.kotlinx.dataframe.api.name
+import org.jetbrains.kotlinx.dataframe.codeGen.CodeWithConverter
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
+import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.CodeGenerationReadResult
+import org.jetbrains.kotlinx.dataframe.impl.codeGen.urlCodeGenReader
+import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
+import org.jetbrains.kotlinx.dataframe.impl.renderType
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.SupportedCodeGenerationFormat
+import org.jetbrains.kotlinx.dataframe.io.supportedFormats
+import org.jetbrains.kotlinx.jupyter.api.*
+import org.jetbrains.kotlinx.jupyter.api.libraries.*
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+
+/** Users will get an error if their Kotlin Jupyter kernel is older than this version. */
+private const val MIN_KERNEL_VERSION = "0.11.0.198"
+
+internal val newDataSchemas = mutableListOf<KClass<*>>()
+
+internal class Integration(
+    private val notebook: Notebook,
+    private val options: MutableMap<String, String?>,
+) : JupyterIntegration() {
+
+    val version = options["v"]
+
+    private fun KotlinKernelHost.execute(codeWithConverter: CodeWithConverter, argument: String): VariableName? {
+        val code = codeWithConverter.with(argument)
+        return if (code.isNotBlank()) {
+            val result = execute(code)
+            if (codeWithConverter.hasConverter) {
+                result.name
+            } else null
+        } else null
+    }
+
+    private fun KotlinKernelHost.execute(
+        codeWithConverter: CodeWithConverter,
+        property: KProperty<*>,
+        type: KType,
+    ): VariableName? {
+        val variableName = "(${property.name}${if (property.returnType.isMarkedNullable) "!!" else ""} as $type)"
+        return execute(codeWithConverter, variableName)
+    }
+
+    private fun KotlinKernelHost.updateImportDataSchemaVariable(
+        importDataSchema: ImportDataSchema,
+        property: KProperty<*>,
+    ): VariableName? {
+        val formats = supportedFormats.filterIsInstance<SupportedCodeGenerationFormat>()
+        val name = property.name + "DataSchema"
+        return when (
+            val codeGenResult = CodeGenerator.urlCodeGenReader(importDataSchema.url, name, formats, true)
+        ) {
+            is CodeGenerationReadResult.Success -> {
+                val readDfMethod = codeGenResult.getReadDfMethod(importDataSchema.url.toExternalForm())
+                val code = readDfMethod.additionalImports.joinToString("\n") +
+                    "\n" +
+                    codeGenResult.code
+
+                execute(code)
+                execute("""DISPLAY("Data schema successfully imported as ${property.name}: $name")""")
+
+                name
+            }
+
+            is CodeGenerationReadResult.Error -> {
+                execute("""DISPLAY("Failed to read data schema from ${importDataSchema.url}: ${codeGenResult.reason}")""")
+                null
+            }
+        }
+    }
+
+    private fun KotlinKernelHost.updateAnyFrameVariable(
+        df: AnyFrame,
+        property: KProperty<*>,
+        codeGen: ReplCodeGenerator,
+    ): VariableName? = execute(
+        codeWithConverter = codeGen.process(df, property),
+        property = property,
+        type = DataFrame::class.createStarProjectedType(false),
+
+    )
+
+    private fun KotlinKernelHost.updateAnyRowVariable(
+        row: AnyRow,
+        property: KProperty<*>,
+        codeGen: ReplCodeGenerator,
+    ): VariableName? = execute(
+        codeWithConverter = codeGen.process(row, property),
+        property = property,
+        type = DataRow::class.createStarProjectedType(false),
+    )
+
+    private fun KotlinKernelHost.updateColumnGroupVariable(
+        col: ColumnGroup<*>,
+        property: KProperty<*>,
+        codeGen: ReplCodeGenerator,
+    ): VariableName? = execute(
+        codeWithConverter = codeGen.process(col.asDataFrame(), property),
+        property = property,
+        type = ColumnGroup::class.createStarProjectedType(false),
+    )
+
+    private fun KotlinKernelHost.updateAnyColVariable(
+        col: AnyCol,
+        property: KProperty<*>,
+        codeGen: ReplCodeGenerator,
+    ): VariableName? = if (col.isColumnGroup()) {
+        val codeWithConverter = codeGen.process(col.asColumnGroup().asDataFrame(), property).let { c ->
+            CodeWithConverter(c.declarations) { c.converter("$it.asColumnGroup()") }
+        }
+        execute(
+            codeWithConverter = codeWithConverter,
+            property = property,
+            type = DataColumn::class.createStarProjectedType(false),
+        )
+    } else {
+        null
+    }
+
+    override fun Builder.onLoaded() {
+        if (version != null) {
+            dependencies(
+                "org.jetbrains.kotlinx:dataframe-excel:$version",
+                "org.jetbrains.kotlinx:dataframe-jdbc:$version",
+                "org.jetbrains.kotlinx:dataframe-arrow:$version",
+                "org.jetbrains.kotlinx:dataframe-openapi:$version",
+            )
+        }
+
+        try {
+            setMinimalKernelVersion(MIN_KERNEL_VERSION)
+        } catch (_: NoSuchMethodError) { // will be thrown when a version < 0.11.0.198
+            throw IllegalStateException(
+                getKernelUpdateMessage(notebook.kernelVersion, MIN_KERNEL_VERSION, notebook.jupyterClientType)
+            )
+        }
+        val codeGen = ReplCodeGenerator.create()
+        val config = JupyterConfiguration()
+
+        if (notebook.jupyterClientType == JupyterClientType.KOTLIN_NOTEBOOK) {
+            config.display.isolatedOutputs = true
+        }
+
+        onLoaded {
+            declare("dataFrameConfig" to config)
+        }
+
+        resources {
+            if (!config.display.isolatedOutputs) {
+                js("DataFrame") {
+                    if (config.display.localTesting) {
+                        classPath("init.js")
+                    } else {
+                        // Update this commit when new version of init.js is pushed
+                        val initJsSha = "3db46ccccaa1291c0627307d64133317f545e6ae"
+                        url("https://cdn.jsdelivr.net/gh/Kotlin/dataframe@$initJsSha/core/src/main/resources/init.js")
+                    }
+                }
+
+                css("DataFrameTable") { classPath("table.css") }
+            }
+        }
+
+        with(JupyterHtmlRenderer(config.display, this)) {
+            render<DisableRowsLimitWrapper>(
+                { "DataRow: index = ${it.value.rowsCount()}, columnsCount = ${it.value.columnsCount()}" },
+                applyRowsLimit = false
+            )
+
+            render<GroupClause<*, *>>({ "Group" })
+            render<MoveClause<*, *>>({ "Move" })
+            render<RenameClause<*, *>>({ "Rename" })
+            render<ReplaceClause<*, *>>({ "Replace" })
+            render<InsertClause<*>>({ "Insert" })
+            render<FormatClause<*, *>>({ "Format" })
+
+            render<DataFrameHtmlData> {
+                // Our integration declares script and css definition. But in Kotlin Notebook outputs are isolated in IFrames
+                // That's why we include them directly in the output
+                if (notebook.jupyterClientType == JupyterClientType.KOTLIN_NOTEBOOK) {
+                    it.withTableDefinitions().toJupyterHtmlData().toIFrame(notebook.currentColorScheme)
+                } else {
+                    it.toJupyterHtmlData().toSimpleHtml(notebook.currentColorScheme)
+                }
+            }
+
+            render<AnyRow>(
+                { "DataRow: index = ${it.index()}, columnsCount = ${it.columnsCount()}" },
+            )
+            render<ColumnGroup<*>>(
+                { """ColumnGroup: name = "${it.name}", rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}""" },
+            )
+            render<AnyCol>(
+                { """DataColumn: name = "${it.name}", type = ${renderType(it.type())}, size = ${it.size()}""" },
+            )
+            render<AnyFrame>(
+                { "DataFrame: rowsCount = ${it.rowsCount()}, columnsCount = ${it.columnsCount()}" }
+            )
+            render<FormattedFrame<*>>(
+                { "DataFrame: rowsCount = ${it.df.rowsCount()}, columnsCount = ${it.df.columnsCount()}" },
+                modifyConfig = { getDisplayConfiguration(it) },
+            )
+            render<GroupBy<*, *>>({ "GroupBy" })
+            render<ReducedGroupBy<*, *>>({ "ReducedGroupBy" })
+            render<Pivot<*>>({ "Pivot" })
+            render<ReducedPivot<*>>({ "ReducedPivot" })
+            render<PivotGroupBy<*>>({ "PivotGroupBy" })
+            render<ReducedPivotGroupBy<*>>({ "ReducedPivotGroupBy" })
+            render<SplitWithTransform<*, *, *>>({ "Split" })
+            render<Split<*, *>>({ "Split" })
+            render<Merge<*, *, *>>({ "Merge" })
+            render<Gather<*, *, *, *>>({ "Gather" })
+            render<IMG> { HTML(it.toString()) }
+            render<IFRAME> { HTML(it.toString()) }
+            render<Update<*, *>>({ "Update" })
+            render<Convert<*, *>>({ "Convert" })
+        }
+
+        import("org.jetbrains.kotlinx.dataframe.api.*")
+        import("org.jetbrains.kotlinx.dataframe.*")
+        import("org.jetbrains.kotlinx.dataframe.annotations.*")
+        import("org.jetbrains.kotlinx.dataframe.io.*")
+        import("org.jetbrains.kotlinx.dataframe.columns.*")
+        import("org.jetbrains.kotlinx.dataframe.jupyter.ImportDataSchema")
+        import("org.jetbrains.kotlinx.dataframe.jupyter.importDataSchema")
+        import("org.jetbrains.kotlinx.dataframe.jupyter.KotlinNotebookPluginUtils")
+        import("java.net.URL")
+        import("java.io.File")
+        import("kotlinx.datetime.Instant")
+        import("kotlinx.datetime.LocalDateTime")
+        import("kotlinx.datetime.LocalDate")
+        import("org.jetbrains.kotlinx.dataframe.dataTypes.*")
+        import("org.jetbrains.kotlinx.dataframe.impl.codeGen.urlCodeGenReader")
+
+        addTypeConverter(object : FieldHandler {
+            override val execution = FieldHandlerFactory.createUpdateExecution<Any> { instance, property ->
+                when (instance) {
+                    is AnyCol -> updateAnyColVariable(instance, property, codeGen)
+                    is ColumnGroup<*> -> updateColumnGroupVariable(instance, property, codeGen)
+                    is AnyRow -> updateAnyRowVariable(instance, property, codeGen)
+                    is AnyFrame -> updateAnyFrameVariable(instance, property, codeGen)
+                    is ImportDataSchema -> updateImportDataSchemaVariable(instance, property)
+                    else -> error("${instance::class} should not be handled by Dataframe field handler")
+                }
+            }
+            override fun accepts(value: Any?, property: KProperty<*>): Boolean {
+                return value is AnyCol ||
+                    value is ColumnGroup<*> ||
+                    value is AnyRow ||
+                    value is AnyFrame ||
+                    value is ImportDataSchema
+            }
+        })
+
+        fun KotlinKernelHost.addDataSchemas(classes: List<KClass<*>>) {
+            val code = classes.joinToString("\n") {
+                codeGen.process(it)
+            }.trim()
+
+            if (code.isNotEmpty()) {
+                execute(code)
+            }
+        }
+
+        onClassAnnotation<DataSchema> { addDataSchemas(it) }
+
+        beforeCellExecution {
+            if (newDataSchemas.isNotEmpty()) {
+                addDataSchemas(newDataSchemas)
+                newDataSchemas.clear()
+            }
+        }
+
+        val internalTypes = listOf(
+            ColumnReference::class,
+        ).map { it.createStarProjectedType(true) }
+
+        markVariableInternal { property ->
+            // TODO: add more conditions to include all generated properties and other internal stuff
+            //  that should not be shown to user in Jupyter variables view
+            internalTypes.any { property.returnType.isSubtypeOf(it) }
+        }
+
+        onColorSchemeChange {
+            config.display.useDarkColorScheme = (it == ColorScheme.DARK)
+        }
+    }
+}
+
+public fun KotlinKernelHost.useSchemas(schemaClasses: Iterable<KClass<*>>) {
+    newDataSchemas.addAll(schemaClasses)
+}
+
+public fun KotlinKernelHost.useSchemas(vararg schemaClasses: KClass<*>): Unit = useSchemas(schemaClasses.asIterable())
+
+public inline fun <reified T> KotlinKernelHost.useSchema(): Unit = useSchemas(T::class)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCellRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCellRenderer.kt
new file mode 100644
index 000000000..dfc46cb4a
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCellRenderer.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.internallyRenderable
+import org.jetbrains.kotlinx.dataframe.io.renderValueForHtml
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.Renderable
+import org.jetbrains.kotlinx.jupyter.api.libraries.ExecutionHost
+
+internal class JupyterCellRenderer(
+    private val notebook: Notebook,
+    private val host: ExecutionHost,
+) : ChainedCellRenderer(DefaultCellRenderer) {
+    override fun maybeContent(value: Any?, configuration: DisplayConfiguration): RenderedContent? {
+        val renderersProcessor = notebook.renderersProcessor
+        if (internallyRenderable(value)) return null
+        val renderedVal = renderersProcessor.renderValue(host, value)
+        val finalVal = if (renderedVal is Renderable) renderedVal.render(notebook) else renderedVal
+        if (finalVal is MimeTypedResult && "text/html" in finalVal) return RenderedContent.media(
+            finalVal["text/html"] ?: ""
+        )
+        return renderValueForHtml(finalVal, configuration.cellContentLimit, configuration.decimalFormat)
+    }
+
+    override fun maybeTooltip(value: Any?, configuration: DisplayConfiguration): String? {
+        return null
+    }
+}
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
new file mode 100644
index 000000000..4d8e91bff
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterHtmlRenderer.kt
@@ -0,0 +1,131 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.addAll
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import kotlinx.serialization.json.putJsonArray
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.COLUMNS
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NCOL
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.NROW
+import org.jetbrains.kotlinx.dataframe.impl.io.encodeFrame
+import org.jetbrains.kotlinx.dataframe.io.Base64ImageEncodingOptions
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.toHTML
+import org.jetbrains.kotlinx.dataframe.io.toJsonWithMetadata
+import org.jetbrains.kotlinx.dataframe.io.toStaticHtml
+import org.jetbrains.kotlinx.dataframe.jupyter.KotlinNotebookPluginUtils.convertToDataFrame
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.jetbrains.kotlinx.dataframe.size
+import org.jetbrains.kotlinx.jupyter.api.HtmlData
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType
+import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.api.Notebook
+import org.jetbrains.kotlinx.jupyter.api.libraries.JupyterIntegration
+import org.jetbrains.kotlinx.jupyter.api.mimeResult
+import org.jetbrains.kotlinx.jupyter.api.outputs.isIsolatedHtml
+import org.jetbrains.kotlinx.jupyter.api.renderHtmlAsIFrameIfNeeded
+
+/** Starting from this version, dataframe integration will respond with additional data for rendering in Kotlin Notebooks plugin. */
+private const val MIN_KERNEL_VERSION_FOR_NEW_TABLES_UI = "0.11.0.311"
+private const val MIN_IDE_VERSION_SUPPORT_JSON_WITH_METADATA = 241
+private const val MIN_IDE_VERSION_SUPPORT_IMAGE_VIEWER = 242
+
+internal class JupyterHtmlRenderer(
+    val display: DisplayConfiguration,
+    val builder: JupyterIntegration.Builder,
+)
+
+@OptIn(ExperimentalSerializationApi::class)
+internal inline fun <reified T : Any> JupyterHtmlRenderer.render(
+    noinline getFooter: (T) -> String,
+    crossinline modifyConfig: T.(DisplayConfiguration) -> DisplayConfiguration = { it },
+    applyRowsLimit: Boolean = true,
+) = builder.renderWithHost<T> { host, value ->
+    val contextRenderer = JupyterCellRenderer(this.notebook, host)
+    val reifiedDisplayConfiguration = value.modifyConfig(display)
+    val footer = getFooter(value)
+
+    val df = convertToDataFrame(value)
+
+    val limit = if (applyRowsLimit) {
+        reifiedDisplayConfiguration.rowsLimit ?: df.nrow
+    } else {
+        df.nrow
+    }
+
+    val html = DataFrameHtmlData.tableDefinitions(
+        includeJs = reifiedDisplayConfiguration.isolatedOutputs,
+        includeCss = true,
+    ).plus(
+        df.toHTML(
+            // is added later to make sure it's put outside of potential iFrames
+            configuration = reifiedDisplayConfiguration.copy(enableFallbackStaticTables = false),
+            cellRenderer = contextRenderer,
+        ) { footer }
+    ).toJupyterHtmlData()
+
+    // Generates a static version of the table which can be displayed in GitHub previews etc.
+    val staticHtml = df.toStaticHtml(reifiedDisplayConfiguration, DefaultCellRenderer).toJupyterHtmlData()
+
+    if (notebook.kernelVersion >= KotlinKernelVersion.from(MIN_KERNEL_VERSION_FOR_NEW_TABLES_UI)!!) {
+        val ideBuildNumber = KotlinNotebookPluginUtils.getKotlinNotebookIDEBuildNumber()
+
+        // TODO Do we need to handle the improved meta data here as well?
+        val jsonEncodedDf = when {
+            !ideBuildNumber.supportsDynamicNestedTables() -> {
+                buildJsonObject {
+                    put(NROW, df.size.nrow)
+                    put(NCOL, df.size.ncol)
+                    putJsonArray(COLUMNS) { addAll(df.columnNames()) }
+                    put(KOTLIN_DATAFRAME, encodeFrame(df.take(limit)))
+                }.toString()
+            }
+
+            else -> {
+                val imageEncodingOptions =
+                    if (ideBuildNumber.supportsImageViewer()) Base64ImageEncodingOptions() else null
+
+                df.toJsonWithMetadata(
+                    limit,
+                    reifiedDisplayConfiguration.rowsLimit,
+                    imageEncodingOptions = imageEncodingOptions
+                )
+            }
+        }
+
+        notebook.renderAsIFrameAsNeeded(html, staticHtml, jsonEncodedDf)
+    } else {
+        notebook.renderHtmlAsIFrameIfNeeded(html)
+    }
+}
+
+private fun KotlinNotebookPluginUtils.IdeBuildNumber?.supportsDynamicNestedTables() =
+    this != null && majorVersion >= MIN_IDE_VERSION_SUPPORT_JSON_WITH_METADATA
+
+private fun KotlinNotebookPluginUtils.IdeBuildNumber?.supportsImageViewer() =
+    this != null && majorVersion >= MIN_IDE_VERSION_SUPPORT_IMAGE_VIEWER
+
+internal fun Notebook.renderAsIFrameAsNeeded(
+    data: HtmlData,
+    staticData: HtmlData,
+    jsonEncodedDf: String
+): MimeTypedResult {
+    val textHtml = if (jupyterClientType == JupyterClientType.KOTLIN_NOTEBOOK) {
+        data.generateIframePlaneText(currentColorScheme) +
+            staticData.toString(currentColorScheme)
+    } else {
+        (data + staticData).toString(currentColorScheme)
+    }
+
+    return mimeResult(
+        "text/html" to textHtml,
+        "application/kotlindataframe+json" to jsonEncodedDf
+    ).also { it.isIsolatedHtml = false }
+}
+
+internal fun DataFrameHtmlData.toJupyterHtmlData() = HtmlData(style, body, script)
diff --git a/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
new file mode 100644
index 000000000..1950168a2
--- /dev/null
+++ b/core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/kernelUpdateMessages.kt
@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType.DATALORE
+import org.jetbrains.kotlinx.jupyter.api.JupyterClientType.KOTLIN_NOTEBOOK
+import org.jetbrains.kotlinx.jupyter.api.KotlinKernelVersion
+
+private const val UPDATING_DATALORE_URL = "https://github.com/Kotlin/kotlin-jupyter/tree/master#datalore"
+private const val UPDATING_KOTLIN_NOTEBOOK_URL = "https://github.com/Kotlin/kotlin-jupyter#kotlin-notebook"
+private const val UPDATING = "https://github.com/Kotlin/kotlin-jupyter/tree/master#updating"
+
+internal fun getKernelUpdateMessage(
+    kernelVersion: KotlinKernelVersion,
+    minKernelVersion: String,
+    clientType: JupyterClientType,
+): String = buildString {
+    append("Your Kotlin Jupyter kernel version appears to be out of date (version $kernelVersion). ")
+    appendLine("Please update it to version $minKernelVersion or newer to be able to use DataFrame.")
+    append("Follow the instructions at: ")
+
+    when (clientType) {
+        DATALORE -> appendLine(UPDATING_DATALORE_URL)
+        KOTLIN_NOTEBOOK -> appendLine(UPDATING_KOTLIN_NOTEBOOK_URL)
+        else -> appendLine(UPDATING)
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
new file mode 100644
index 000000000..a7f1d28e1
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/CodeGenerationTests.kt
@@ -0,0 +1,64 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.jupyter.api.Code
+import org.junit.Test
+
+class CodeGenerationTests : DataFrameJupyterTest() {
+
+    private fun Code.checkCompilation() {
+        lines().forEach {
+            execRendered(it)
+        }
+    }
+
+    @Test
+    fun `Type erased dataframe`() {
+        @Language("kts")
+        val a = """
+            fun create(): Any? = dataFrameOf("a")(1)
+            val df = create()
+            df.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable dataframe`() {
+        @Language("kts")
+        val a = """
+            fun create(): AnyFrame? = dataFrameOf("a")(1)
+            val df = create()
+            df.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable columnGroup`() {
+        @Language("kts")
+        val a = """
+            fun create(): AnyCol? = dataFrameOf("a")(1).asColumnGroup().asDataColumn()
+            val col = create()
+            col.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `nullable dataRow`() {
+        @Language("kts")
+        val a = """
+            fun create(): AnyRow? = dataFrameOf("a")(1).single()
+            val row = create()
+            row.a
+        """.checkCompilation()
+    }
+
+    @Test
+    fun `interface without body compiled correctly`() {
+        """
+            val a = dataFrameOf("a")(1, 2, 3)
+            val b = dataFrameOf("b")(1, 2, 3)
+            val ab = dataFrameOf("a", "b")(1, 2)
+            ab.a
+        """.checkCompilation()
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
new file mode 100644
index 000000000..f56be9591
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/DataFrameJupyterTest.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.jupyter.parser.notebook.Cell
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.jetbrains.kotlinx.jupyter.testkit.ReplProvider
+
+abstract class DataFrameJupyterTest : JupyterReplTestCase(
+    ReplProvider.forLibrariesTesting(listOf("dataframe"))
+)
+
+fun interface CodeReplacer {
+    fun replace(code: String): String
+
+    companion object {
+        val DEFAULT = CodeReplacer { it }
+
+        fun byMap(replacements: Map<String, String>) = CodeReplacer { code ->
+            replacements.entries.fold(code) { acc, (key, replacement) ->
+                acc.replace(key, replacement)
+            }
+        }
+
+        fun byMap(vararg replacements: Pair<String, String>): CodeReplacer = byMap(mapOf(*replacements))
+    }
+}
+
+fun interface CellClause {
+    fun isAccepted(cell: Cell): Boolean
+
+    companion object {
+        val IS_CODE = CellClause { it.type == Cell.Type.CODE }
+    }
+}
+
+infix fun CellClause.and(other: CellClause): CellClause {
+    return CellClause { cell ->
+        // Prevent lazy evaluation
+        val acceptedThis = this.isAccepted(cell)
+        val acceptedOther = other.isAccepted(cell)
+        acceptedThis && acceptedOther
+    }
+}
+
+fun CellClause.Companion.stopAfter(breakClause: CellClause) = object : CellClause {
+    var clauseTriggered: Boolean = false
+
+    override fun isAccepted(cell: Cell): Boolean {
+        clauseTriggered = clauseTriggered || breakClause.isAccepted(cell)
+        return !clauseTriggered
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
new file mode 100644
index 000000000..05bc5d32a
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/JupyterCodegenTests.kt
@@ -0,0 +1,357 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.matchers.should
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.jetbrains.kotlinx.dataframe.api.isNotEmpty
+import org.jetbrains.kotlinx.dataframe.columns.ValueColumn
+import org.jetbrains.kotlinx.dataframe.type
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class JupyterCodegenTests : JupyterReplTestCase() {
+
+    @Test
+    fun `codegen adding column with generic type function`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            fun <T> AnyFrame.addValue(value: T) = add("value") { listOf(value) }
+            val df = dataFrameOf("a")(1).addValue(2)
+            """.trimIndent()
+        )
+        res1 shouldBe Unit
+
+        @Language("kts")
+        val res2 = execRaw("df") as AnyFrame
+
+        res2["value"].type shouldBe typeOf<List<Any?>>()
+    }
+
+    @Test
+    fun `Don't inherit from data class`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            data class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Don't inherit from non open class`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Don't inherit from open class`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            open class A(val a: Int)
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `Do inherit from open interface`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            interface A { val a: Int }
+            """.trimIndent()
+        )
+
+        @Language("kts")
+        val res2 = execRaw(
+            """
+            val df = dataFrameOf("a", "b")(1, 2)
+            df
+            """.trimIndent()
+        )
+
+        (res2 as AnyFrame).should { it.isNotEmpty() }
+    }
+
+    @Test
+    fun `codegen for enumerated frames`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val names = (0..2).map { it.toString() }
+            val df = dataFrameOf(names)(1, 2, 3)
+            """.trimIndent()
+        )
+        res1 shouldBe Unit
+
+        @Language("kts")
+        val res2 = execRaw("df.`1`")
+        res2.shouldBeInstanceOf<ValueColumn<*>>()
+    }
+
+    @Test
+    fun `codegen for complex column names`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("[a], (b), {c}\n1, 2, 3")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """listOf(df.`{a}`[0], df.`(b)`[0], df.`{c}`[0])"""
+        )
+        res2 shouldBe listOf(1, 2, 3)
+    }
+
+    @Test
+    fun `codegen for '$' that is interpolator in kotlin string literals`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("\${'$'}id\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`\$id`[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for backtick that is forbidden in kotlin identifiers`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("Day`s\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`Day's`[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for chars that is forbidden in JVM identifiers`() {
+        val forbiddenChar = ";"
+
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("Test$forbiddenChar\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`Test `[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `codegen for chars that is forbidden in JVM identifiers 1`() {
+        val forbiddenChar = "\\\\"
+
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            val df = DataFrame.readDelimStr("Test$forbiddenChar\n1")
+            df
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<MimeTypedResult>()
+        println(res1.entries.joinToString())
+
+        @Language("kts")
+        val res2 = execRendered(
+            "listOf(df.`Test `[0])"
+        )
+        res2 shouldBe listOf(1)
+    }
+
+    @Test
+    fun `generic interface`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+            @DataSchema
+            interface Generic<T> {
+                val field: T
+            }
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<Unit>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """
+                val <T> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+                val <T> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent()
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generic interface with upper bound`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+                @DataSchema
+                interface Generic <T : String> {
+                    val field: T
+                }
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<Unit>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """
+                val <T : String> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+                val <T : String> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent()
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `generic interface with variance and user type in type parameters`() {
+        @Language("kts")
+        val res1 = execRendered(
+            """
+                interface UpperBound
+
+                @DataSchema(isOpen = false)
+                interface Generic <out T : UpperBound> {
+                    val field: T
+                }
+            """.trimIndent()
+        )
+        res1.shouldBeInstanceOf<Unit>()
+
+        @Language("kts")
+        val res2 = execRendered(
+            """
+                val <T : UpperBound> ColumnsContainer<Generic<T>>.test1: DataColumn<T> get() = field
+                val <T : UpperBound> DataRow<Generic<T>>.test2: T get() = field
+            """.trimIndent()
+        )
+        res2.shouldBeInstanceOf<Unit>()
+    }
+
+    @Test
+    fun `type converter does not conflict with other type converters`() {
+        @Language("kts")
+        val anotherTypeConverter = """
+            notebook.fieldsHandlersProcessor.register(
+                FieldHandlerFactory.createUpdateHandler<ByteArray>(TypeDetection.RUNTIME) { _, prop ->
+                     execute(prop.name + ".toList()").name
+                },
+                ProcessingPriority.LOW
+            )
+        """.trimIndent()
+        execEx(anotherTypeConverter)
+        execEx("val x = ByteArray(1)")
+        val res1 = execRaw("x")
+        res1.shouldBeInstanceOf<List<*>>()
+    }
+
+    @Test
+    fun `generate a new marker when dataframe marker is not a data schema so that columns are accessible with extensions`() {
+        @Language("kts")
+        val a = execRendered(
+            """
+            enum class State {
+                Idle, Productive, Maintenance
+            }
+
+            class Event(val toolId: String, val state: State, val timestamp: Long)
+
+            val tool1 = "tool_1"
+            val tool2 = "tool_2"
+            val tool3 = "tool_3"
+            val events = listOf(
+                Event(tool1, State.Idle, 0),
+                Event(tool1, State.Productive, 5),
+                Event(tool2, State.Idle, 0),
+                Event(tool2, State.Maintenance, 10),
+                Event(tool2, State.Idle, 20),
+                Event(tool3, State.Idle, 0),
+                Event(tool3, State.Productive, 25),
+            ).toDataFrame()
+            """.trimIndent()
+        )
+        shouldNotThrowAny {
+            @Language("kts")
+            val b = execRendered(
+                """
+                events.toolId
+                events.state
+                events.timestamp
+                """.trimIndent()
+            )
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
new file mode 100644
index 000000000..f544c349b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/RenderingTests.kt
@@ -0,0 +1,410 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.assertions.throwables.shouldNotThrow
+import io.kotest.matchers.comparables.shouldBeGreaterThan
+import io.kotest.matchers.comparables.shouldBeLessThan
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.int
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.intellij.lang.annotations.Language
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.DATA
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.KOTLIN_DATAFRAME
+import org.jetbrains.kotlinx.dataframe.impl.io.SerializationKeys.METADATA
+import org.jetbrains.kotlinx.jupyter.api.MimeTypedResult
+import org.jetbrains.kotlinx.jupyter.testkit.JupyterReplTestCase
+import org.junit.BeforeClass
+import org.junit.Test
+
+class RenderingTests : JupyterReplTestCase() {
+    @Test
+    fun `dataframe is rendered to html`() {
+        @Language("kts")
+        val html = execHtml(
+            """
+            val name by column<String>()
+            val height by column<Int>()
+            val df = dataFrameOf(name, height)(
+                "Bill", 135,
+                "Charlie", 160
+            )
+            df
+            """.trimIndent()
+        )
+        html shouldContain "Bill"
+
+        @Language("kts")
+        val useRes = execRendered(
+            """
+            USE {
+                render<Int> { (it * 2).toString() }
+            }
+            """.trimIndent()
+        )
+        useRes shouldBe Unit
+
+        val html2 = execHtml("df")
+        html2 shouldContain (135 * 2).toString()
+        html2 shouldContain (160 * 2).toString()
+    }
+
+    @Test
+    fun `rendering options`() {
+        @Language("kts")
+        val html1 = execHtml(
+            """
+            data class Person(val age: Int, val name: String)
+            val df = (1..70).map { Person(it, "A".repeat(it)) }.toDataFrame()
+            df
+            """.trimIndent()
+        )
+        html1 shouldContain "showing only top 20 of 70 rows"
+
+        @Language("kts")
+        val html2 = execHtml(
+            """
+            dataFrameConfig.display.rowsLimit = 50
+            df
+            """.trimIndent()
+        )
+        html2 shouldContain "showing only top 50 of 70 rows"
+    }
+
+    @Test
+    fun `dark color scheme`() {
+        fun execSimpleDf() = execHtml("""dataFrameOf("a", "b")(1, 2, 3, 4)""")
+
+        val htmlLight = execSimpleDf()
+        val r1 = execRendered("notebook.changeColorScheme(ColorScheme.DARK); 1")
+        val htmlDark = execSimpleDf()
+
+        r1 shouldBe 1
+        val darkClassAttribute = """theme='dark'"""
+        htmlLight shouldNotContain darkClassAttribute
+        htmlDark shouldContain darkClassAttribute
+    }
+
+    @Test
+    fun `test kotlin notebook plugin utils rows subset`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val id: Int)
+            val df = (1..100).map { Row(it) }.toDataFrame()
+            KotlinNotebookPluginUtils.getRowsSubsetForRendering(df, 20 , 50)
+            """.trimIndent()
+        )
+
+        assertDataFrameDimensions(json, 30, 1)
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray
+        rows.getObj(0)["id"]?.jsonPrimitive?.int shouldBe 21
+        rows.getObj(rows.lastIndex)["id"]?.jsonPrimitive?.int shouldBe 50
+    }
+
+    /**
+     * Executes the given `script` and parses the resulting DataFrame as a `JsonObject`.
+     *
+     * @param script the script to be executed
+     * @return the parsed DataFrame result as a `JsonObject`
+     */
+    private fun executeScriptAndParseDataframeResult(@Language("kts") script: String): JsonObject {
+        val result = execRendered<MimeTypedResult>(script)
+        return parseDataframeJson(result)
+    }
+
+    private fun assertDataFrameDimensions(json: JsonObject, expectedRows: Int, expectedColumns: Int) {
+        json[METADATA]!!.jsonObject["nrow"]!!.jsonPrimitive.int shouldBe expectedRows
+        json[METADATA]!!.jsonObject["ncol"]!!.jsonPrimitive.int shouldBe expectedColumns
+    }
+
+    private fun parseDataframeJson(result: MimeTypedResult): JsonObject {
+        return Json.decodeFromString<JsonObject>(result["application/kotlindataframe+json"]!!)
+    }
+
+    private fun JsonArray.getObj(index: Int) = this[index].jsonObject
+
+    @Test
+    fun `test kotlin notebook plugin utils sort by one column asc`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class CustomRow(val id: Int, val category: String)
+            val df = (1..100).map { CustomRow(it, if (it % 2 == 0) "even" else "odd") }.toDataFrame()
+            KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("id")), listOf(false))
+            """.trimIndent()
+        )
+
+        assertDataFrameDimensions(json, 100, 2)
+        assertSortedById(json, false)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun assertSortedById(json: JsonObject, desc: Boolean) {
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray as List<JsonObject>
+        var previousId = if (desc) 101 else 0
+        rows.forEach { row: JsonObject ->
+            val currentId = row["id"]!!.jsonPrimitive.int
+            if (desc) currentId shouldBeLessThan previousId else currentId shouldBeGreaterThan previousId
+            previousId = currentId
+        }
+    }
+
+    @Test
+    fun `test kotlin notebook plugin utils sort by one column desc`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class CustomRow(val id: Int, val category: String)
+            val df = (1..100).map { CustomRow(it, if (it % 2 == 0) "even" else "odd") }.toDataFrame()
+            KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("id")), listOf(true))
+            """.trimIndent()
+        )
+
+        assertDataFrameDimensions(json, 100, 2)
+        assertSortedById(json, true)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Test
+    fun `test kotlin notebook plugin utils sort by multiple columns`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class CustomRow(val id: Int, val category: String)
+            val df = (1..100).map { CustomRow(it, if (it % 2 == 0) "even" else "odd") }.toDataFrame()
+            KotlinNotebookPluginUtils.getRowsSubsetForRendering(
+                KotlinNotebookPluginUtils.sortByColumns(df, listOf(listOf("category"), listOf("id")), listOf(true, false)),
+                0, 100
+            )
+            """.trimIndent()
+        )
+
+        assertDataFrameDimensions(json, 100, 2)
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray as List<JsonObject>
+        assertSortedByCategory(rows)
+        assertSortedById(rows)
+    }
+
+    private fun assertSortedByCategory(rows: List<JsonObject>) {
+        rows.forEachIndexed { i, row ->
+            val currentCategory = row["category"]!!.jsonPrimitive.content
+            if (i < 50) currentCategory shouldBe "odd"
+            else currentCategory shouldBe "even"
+        }
+    }
+
+    private fun assertSortedById(rows: List<JsonObject>) {
+        var previousCategory = "odd"
+        var previousId = 0
+        for (row in rows) {
+            val currentCategory = row["category"]!!.jsonPrimitive.content
+            val currentId = row["id"]!!.jsonPrimitive.int
+
+            if (previousCategory == "odd" && currentCategory == "even") {
+                previousId shouldBeGreaterThan currentId
+            } else if (previousCategory == currentCategory) {
+                previousId shouldBeLessThan currentId
+            }
+
+            previousCategory = currentCategory
+            previousId = currentId
+        }
+    }
+
+    @Test
+    fun `json metadata contains schema metadata`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+                val col1 by columnOf("a", "b", "c")
+                val col2 by columnOf(1, 2, 3)
+                val col3 by columnOf("Foo", "Bar", null)
+                val df2 = dataFrameOf(Pair("header", listOf("A", "B", "C")))
+                val col4 by columnOf(df2, df2, df2)
+                var df = dataFrameOf(col1, col2, col3, col4)
+                df.group(col1, col2).into("group")            
+            """.trimIndent()
+        )
+        val expectedOutput = """
+            {
+              "${'$'}version": "2.1.0",
+              "metadata": {
+                "columns": ["group", "col3", "col4"],
+                "types": [{
+                  "kind": "ColumnGroup"
+                }, {
+                  "kind": "ValueColumn",
+                  "type": "kotlin.String?"
+                }, {
+                  "kind": "FrameColumn"
+                }],
+                "nrow": 3,
+                "ncol": 3
+              },
+              "kotlin_dataframe": [{
+                "group": {
+                  "data": {
+                    "col1": "a",
+                    "col2": 1
+                  },
+                  "metadata": {
+                    "kind": "ColumnGroup",
+                    "columns": ["col1", "col2"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }, {
+                      "kind": "ValueColumn",
+                      "type": "kotlin.Int"
+                    }]
+                  }
+                },
+                "col3": "Foo",
+                "col4": {
+                  "data": [{
+                    "header": "A"
+                  }, {
+                    "header": "B"
+                  }, {
+                    "header": "C"
+                  }],
+                  "metadata": {
+                    "kind": "FrameColumn",
+                    "columns": ["header"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }],
+                    "ncol": 1,
+                    "nrow": 3
+                  }
+                }
+              }, {
+                "group": {
+                  "data": {
+                    "col1": "b",
+                    "col2": 2
+                  },
+                  "metadata": {
+                    "kind": "ColumnGroup",
+                    "columns": ["col1", "col2"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }, {
+                      "kind": "ValueColumn",
+                      "type": "kotlin.Int"
+                    }]
+                  }
+                },
+                "col3": "Bar",
+                "col4": {
+                  "data": [{
+                    "header": "A"
+                  }, {
+                    "header": "B"
+                  }, {
+                    "header": "C"
+                  }],
+                  "metadata": {
+                    "kind": "FrameColumn",
+                    "columns": ["header"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }],
+                    "ncol": 1,
+                    "nrow": 3
+                  }
+                }
+              }, {
+                "group": {
+                  "data": {
+                    "col1": "c",
+                    "col2": 3
+                  },
+                  "metadata": {
+                    "kind": "ColumnGroup",
+                    "columns": ["col1", "col2"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }, {
+                      "kind": "ValueColumn",
+                      "type": "kotlin.Int"
+                    }]
+                  }
+                },
+                "col3": null,
+                "col4": {
+                  "data": [{
+                    "header": "A"
+                  }, {
+                    "header": "B"
+                  }, {
+                    "header": "C"
+                  }],
+                  "metadata": {
+                    "kind": "FrameColumn",
+                    "columns": ["header"],
+                    "types": [{
+                      "kind": "ValueColumn",
+                      "type": "kotlin.String"
+                    }],
+                    "ncol": 1,
+                    "nrow": 3
+                  }
+                }
+              }]
+            }
+        """.trimIndent()
+        json shouldBe Json.parseToJsonElement(expectedOutput)
+    }
+
+    @Test
+    fun `test kotlin dataframe conversion groupby`() {
+        val json = executeScriptAndParseDataframeResult(
+            """
+            data class Row(val id: Int, val group: Int)
+            val df = (1..20).map { Row(it, if (it <= 10) 1 else 2) }.toDataFrame()
+            KotlinNotebookPluginUtils.convertToDataFrame(df.groupBy("group"))
+            """.trimIndent()
+        )
+
+        assertDataFrameDimensions(json, 2, 2)
+
+        val rows = json[KOTLIN_DATAFRAME]!!.jsonArray
+        rows.getObj(0)["group1"]!!.jsonObject[DATA]!!.jsonArray.size shouldBe 10
+        rows.getObj(1)["group1"]!!.jsonObject[DATA]!!.jsonArray.size shouldBe 10
+    }
+
+    // Regression KTNB-424
+    @Test
+    fun `test kotlin dataframe conversion ReducedGroupBy`() {
+        shouldNotThrow<Throwable> {
+            val json = executeScriptAndParseDataframeResult(
+                """
+                data class Row(val id: Int, val group: Int)
+                val df = (1..100).map { Row(it, if (it <= 50) 1 else 2) }.toDataFrame()
+                KotlinNotebookPluginUtils.convertToDataFrame(df.groupBy("group").first())
+                """.trimIndent()
+            )
+
+            assertDataFrameDimensions(json, 2, 2)
+        }
+    }
+
+    companion object {
+        /**
+         * Set the system property for the IDE version needed for specific serialization testing purposes.
+         */
+        @BeforeClass
+        @JvmStatic
+        internal fun setupOnce() {
+            System.setProperty("KTNB_IDE_BUILD_NUMBER", "IU;241;14015")
+        }
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
new file mode 100644
index 000000000..36077d14b
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ResourcesTest.kt
@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import io.kotest.matchers.shouldNotBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+import java.io.InputStreamReader
+
+class ResourcesTest {
+
+    @Test
+    fun `resources available`() {
+        val res = DataFrame::class.java.getResourceAsStream("/table.html")
+        println(InputStreamReader(res).readText())
+
+        res shouldNotBe null
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
new file mode 100644
index 000000000..b7bcf419e
--- /dev/null
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/SampleNotebooksTests.kt
@@ -0,0 +1,128 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.jetbrains.jupyter.parser.JupyterParser
+import org.jetbrains.jupyter.parser.notebook.CodeCell
+import org.jetbrains.jupyter.parser.notebook.Output
+import org.junit.Ignore
+import org.junit.Test
+import java.io.File
+import java.util.Locale
+
+class SampleNotebooksTests : DataFrameJupyterTest() {
+    @Test
+    @Ignore
+    fun puzzles() = exampleTest("puzzles", "40 puzzles")
+
+    @Test
+    fun github() = exampleTest(
+        "github",
+        cellClause = CellClause.stopAfter { cell ->
+            "personal access token" in cell.source
+        },
+        cleanup = {
+            File("jetbrains.json").delete()
+        }
+    )
+
+    @Test
+    @Ignore
+    fun titanic() = exampleTest(
+        "titanic", "Titanic",
+        replacer = CodeReplacer.byMap(
+            "../../idea-examples/" to "$ideaExamplesPath/"
+        )
+    )
+
+    @Test
+    @Ignore
+    fun wine() = exampleTest(
+        "wine", "WineNetWIthKotlinDL",
+        replacer = CodeReplacer.byMap(
+            testFile("wine", "winequality-red.csv")
+        )
+    )
+
+    @Test
+    @Ignore
+    fun netflix() {
+        val currentLocale = Locale.getDefault()
+        try {
+            // Set explicit locale as of test data contains locale-dependent values (date for parsing)
+            Locale.setDefault(Locale.forLanguageTag("en-US"))
+
+            exampleTest(
+                "netflix",
+                replacer = CodeReplacer.byMap(
+                    testFile("netflix", "country_codes.csv"),
+                    testFile("netflix", "netflix_titles.csv"),
+                )
+            )
+        } finally {
+            Locale.setDefault(currentLocale)
+        }
+    }
+
+    @Test
+    @Ignore
+    fun movies() = exampleTest(
+        "movies",
+        replacer = CodeReplacer.byMap(
+            "ml-latest/movies.csv" to "$ideaExamplesPath/movies/src/main/resources/movies.csv"
+        ),
+        // There is no tags data in repository
+        cellClause = CellClause.stopAfter { cell ->
+            "tags.csv" in cell.source
+        }
+    )
+
+    private fun doTest(
+        notebookPath: String,
+        replacer: CodeReplacer,
+        cellClause: CellClause,
+        cleanup: () -> Unit = {},
+    ) {
+        val notebookFile = File(notebookPath)
+        val notebook = JupyterParser.parse(notebookFile)
+        val finalClause = cellClause and CellClause.IS_CODE
+
+        val codeCellsData = notebook.cells
+            .filter { finalClause.isAccepted(it) }
+            .map { CodeCellData(it.source, (it as? CodeCell)?.outputs.orEmpty()) }
+
+        try {
+            for (codeCellData in codeCellsData) {
+                val code = codeCellData.code
+                val codeToExecute = replacer.replace(code)
+
+                println("Executing code:\n$codeToExecute")
+                val cellResult = execRendered(codeToExecute)
+                println(cellResult)
+            }
+        } finally {
+            cleanup()
+        }
+    }
+
+    private fun exampleTest(
+        dir: String,
+        notebookName: String? = null,
+        replacer: CodeReplacer = CodeReplacer.DEFAULT,
+        cellClause: CellClause = CellClause { true },
+        cleanup: () -> Unit = {},
+    ) {
+        val fileName = if (notebookName == null) "$dir.ipynb" else "$notebookName.ipynb"
+        doTest("$notebookExamplesPath/$dir/$fileName", replacer, cellClause, cleanup)
+    }
+
+    data class CodeCellData(
+        val code: String,
+        val outputs: List<Output>,
+    )
+
+    companion object {
+        const val ideaExamplesPath = "../examples/idea-examples"
+        const val notebookExamplesPath = "../examples/notebooks"
+
+        fun testFile(folder: String, fileName: String) = fileName to "$notebookExamplesPath/$folder/$fileName"
+    }
+}
diff --git a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
index 8e259bc7b..94d351f01 100644
--- a/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
+++ b/core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/HtmlRenderingTests.kt
@@ -8,6 +8,7 @@ import org.jetbrains.kotlinx.dataframe.api.group
 import org.jetbrains.kotlinx.dataframe.api.into
 import org.jetbrains.kotlinx.dataframe.api.parse
 import org.jetbrains.kotlinx.dataframe.io.toStandaloneHTML
+import org.jetbrains.kotlinx.jupyter.util.findNthSubstring
 import org.junit.Ignore
 import org.junit.Test
 import java.awt.Desktop
@@ -37,18 +38,4 @@ class HtmlRenderingTests : BaseTest() {
         html shouldContain "href"
         html.findNthSubstring(address, 2) shouldNotBe -1
     }
-
-    private fun String.findNthSubstring(s: String, n: Int, start: Int = 0): Int {
-        if (n < 1 || start == -1) return -1
-
-        var i = start
-
-        for (k in 1..n) {
-            i = indexOf(s, i)
-            if (i == -1) return -1
-            i += s.length
-        }
-
-        return i - s.length
-    }
 }