Jupie Verses

Where data whispers its secrets, and patterns emerge from complexity. This guide will help you discover all the ways Jupie transforms your notebooks.

Table of Contents

The Heart of Jupie

Overview

Jupie transforms Jupyter notebooks into living, breathing dataflow systems. Your code becomes a constellation of interconnected cells, each one illuminated by its purpose:

1. Dependency Detection

Automatic Analysis

Like a careful reader understanding the threads of a story, Jupie automatically traces the connections in your code:

Defined Variables - Variables created in a cell:

# This cell defines: df, process_data, CONFIG
df = pd.read_csv('data.csv')
CONFIG = {'threshold': 0.5}

def process_data(data):
    return data.dropna()

Used Variables - Variables referenced from other cells:

# This cell uses: df, process_data, CONFIG (from above)
# This cell defines: clean_df
clean_df = process_data(df)
threshold = CONFIG['threshold']

Explicit Annotations

Override automatic detection with comments:

# @jupie-import df, model from data_prep
# Explicitly import variables from another notebook

# @jupie-export predictions, metrics
# Mark variables for export to other notebooks

2. Execution Modes

Run All

Execute all cells in topological (dependency) order:

  1. Analyzes dependency graph
  2. Groups cells by dependency level
  3. Executes level by level
  4. Runs independent cells in parallel within each level

Run Selected Cell

Options when running a single cell:

Resume Execution

Continue from where execution stopped:

Stop Execution

Halt execution mid-run:

Reset

Clear all execution state:

3. Execution States

Each cell has an execution state shown by node color:

StateColorDescription
idleGrayNot yet executed
runningBlueCurrently executing
successGreenExecuted successfully
errorRedExecution failed
staleOrangeNeeds re-execution (upstream changed)

Staleness Detection

A cell becomes "stale" when any upstream cell is re-executed.

4. Parallel Execution

Automatic Parallelization

Jupie identifies cells that can run concurrently:

Level 0: [A]          # A has no dependencies
Level 1: [B, C]       # B and C both depend only on A
Level 2: [D]          # D depends on B and C

Cells B and C execute in parallel since they're independent.

Data Lens — See Your Data Clearly

Data Lens transforms how you understand your DataFrames. With a single click, unveil the hidden patterns, distributions, and anomalies in your data.

Profile Tab

Instant statistical overview of every column in your DataFrame:

Preview Tab

Smart data preview with pagination and filtering:

Charts Tab

One-click visualizations that reveal patterns:

Model Tab

Machine learning insights without leaving your notebook:

Data History

Revolutionary diff visualization for DataFrames:

Detective Jupie — Your AI Partner

Detective Jupie is your AI-powered companion that understands your entire notebook context. Ask questions, get insights, and write code through natural conversation.

Context-Aware Conversations

Unlike generic AI assistants, Detective Jupie sees everything:

Voice-Powered Queries

Speak naturally to your notebook:

Smart Suggestions

Proactive insights as you work:

Presentation Mode — Present With Delight

Transform your notebook into a stunning presentation with a single click. No slides needed — your analysis becomes the presentation.

One-Click Presentations

Enter presentation mode instantly:

Live Charts & Outputs

Your visualizations shine:

Speaker Notes

Professional presentation tools:

Export Options

Share your presentation:

Views & Visualization

Every great story deserves multiple perspectives. Jupie offers different lenses through which to see your work.

View Navigation

Views are accessible via tabs at the top of the Jupie editor:

TabPurpose
SearchFind cells by name, variable, or content
CellsHierarchical tree view controlled by markdown headings
WorkflowInteractive dependency graph
Data LensVariable inspection and data profiling
ProfilingExecution timing analysis
VersionsGit version history

1. Search

Find cells quickly by searching across multiple fields.

Search Fields

Search Results

Results are grouped by match type with color coding:

2. Cells

Hierarchical tree view where markdown cells control the structure.

How It Works

Jupie uses markdown headings (H1-H6) to organize flat notebook cells into a tree:

Cell Display

Each cell shows:

3. Workflow

The soul of Jupie — an interactive visualization where your pipeline becomes a constellation of light. Each connection visible, each dependency illuminated.

Graph Elements

Nodes represent cells:

Edges represent dependencies:

Node Colors by Execution Time

Interactions

ActionHowResult
Select nodeClickHighlights upstream dependencies
Multi-selectCtrl/Cmd + ClickAdd/remove from selection
Move nodeShift + DragReposition node on canvas
Move multipleSelect multiple, then Shift + DragMove all selected together
Box selectShift + Drag on backgroundSelect nodes in rectangle
ZoomScroll wheelZoom in/out (0.1x to 3x)
PanDrag backgroundMove view around

4. Profiling

Analyze execution performance to identify bottlenecks.

Header Statistics

Cell Performance List

Cells ranked by execution time (slowest first):

5. Versions

Every cell tells its own story. Track changes across time, compare moments in your notebook's journey, and never lose the thread of your work.

Commit List

Diff View Modes

Cell Diff Status

Multi-Notebook Harmony

Let your notebooks breathe together. Jupie's breakthrough feature allows data to flow naturally between notebooks — no files, no databases, just pure, seamless connection.

The Problem with Traditional Notebooks

Traditional Jupyter workflows lead to:

The Solution: Split into Multiple Notebooks

Monolithic Notebook (1000 cells)
  |
  V
Split into modular pipeline:
  |
  ├── 01_data_prep.ipynb      (50 cells)
  ├── 02_feature_eng.ipynb    (100 cells)
  ├── 03_train_model.ipynb    (200 cells)
  ├── 04_evaluate.ipynb       (50 cells)
  └── 05_visualize.ipynb      (100 cells)

Variable Piping — The Art of Flow

Jupie introduces variable piping — pass Python objects directly between notebooks, as natural as breathing:

Exporting Variables

# In data_prep.ipynb
# @jupie-export clean_data, config

df = pd.read_csv('raw_data.csv')
clean_data = df.dropna().reset_index(drop=True)
config = {'threshold': 0.5, 'n_features': 10}

Importing Variables

# In feature_eng.ipynb
# @jupie-import clean_data, config from data_prep

# Variables are available immediately - no file I/O!
features = clean_data[clean_data['score'] > config['threshold']]

How It Works

  1. Jupie detects @jupie-export annotations and tracks which variables to expose
  2. When a downstream notebook runs, Jupie automatically injects exported variables
  3. Variables are passed in-memory when possible, serialized only when necessary
  4. Dependency graph ensures correct execution order

Workspace Files (.ipynbw)

A workspace file groups notebooks into a single pipeline:

workspace.ipynbw
├── 01_data_prep.ipynb
├── 02_feature_eng.ipynb
├── 03_train_model.ipynb
└── 04_visualization.ipynb

Creating a Workspace

Method 1: Command Palette

  1. Cmd/Ctrl+Shift+P → "Jupie: Create Workspace File"
  2. Select the folder containing your notebooks
  3. Enter a name for the workspace

Method 2: Manual Creation

Create a .ipynbw file - Jupie will auto-discover notebooks in the same directory.

File Export

Export the dependency graph as image files.

Graph Export

Export the dependency graph:

Selection Export

Export only selected cells as a subgraph - useful for documenting specific parts of your workflow.

Interactive Cells in Jupie

Widget Support

Standard Jupyter widgets work in Jupie:

import ipywidgets as widgets
slider = widgets.IntSlider(value=50, min=0, max=100)
display(slider)

Supported Widget Types

Persistent Kernel Sessions

Interactive cells maintain a persistent kernel:

Themes — Beauty in Every Detail

Built-in Themes

Each theme is crafted to create an atmosphere where your work feels at home:

ThemeDescription
PearlLuminous and serene, like morning light on water
OnyxDeep and luxurious, for those midnight inspirations
BlossomWarm and vibrant, alive with creative energy
CoffeeCozy and inviting, like your favorite café

Theme Switching

  1. Click 🎨 Theme in toolbar
  2. Select theme from dropdown
  3. Instant preview

Command Palette

Access via Cmd/Ctrl+Shift+P and type "Jupie":

CommandDescription
Jupie: Select Kernel SourceChoose between local Python or Jupyter server
Jupie: Select Python InterpreterPick which Python environment to use
Jupie: Connect to Jupyter ServerConnect to a remote Jupyter server by URL
Jupie: Restart KernelRestart the current kernel (clears all variables)
Jupie: Create Workspace FileCreate a new .ipynbw workspace in selected folder
Jupie: Enter Activation KeyEnter license key to activate Jupie
Jupie: Show Activation InfoView current activation status and details
Jupie: DeactivateRemove activation from this machine
Jupie: Show TutorialOpen the Jupie tutorial notebook

Quick Reference

Toolbar Buttons

ButtonAction
⚡ KernelSelect Python kernel
⟳ ResetClear all outputs
▶ Run AllExecute all cells
⏸ ResumeContinue from last stop
⏹ StopHalt execution
🩺 HealthCheck for issues
⚙️ SettingsConfigure options
🎨 ThemeSwitch themes

Keyboard Shortcuts

KeyAction
Cmd/Ctrl+EnterRun selected cell
Shift+EnterRun and select next
Cmd/Ctrl+SSave notebook

Dataflow View Interactions

ActionHow
Select nodeClick
Multi-selectCtrl/Cmd+click
Move nodeShift+drag
Move multipleSelect, then Shift+drag
Box selectShift+drag background
ZoomScroll wheel
PanDrag background

Questions? We're here for you. support@imlore.com

↑