PrismNote

Data science notebook with support for 15+ programming languages, SQL execution across 9+ databases, and intelligent code assistance.

A local-first notebook for data exploration, analysis, and systems programming. Works offline, requires no cloud account, and integrates seamlessly with your existing infrastructure.

---

Core Capabilities

Multi-Language Support

Execute code in 15+ languages with full kernel support:

Data Science: Python, R, Julia, Mojo
Systems Programming: C++, Rust, Go, Zig, Scala
GPU Computing: CUDA C++
Query Languages: SQL (PostgreSQL, MySQL, BigQuery, Snowflake, Redshift, DuckDB, SQLite, T-SQL, Oracle)
Web/Script: TypeScript, JavaScript
Documentation: Markdown, Raw Text

Each language includes:

• Syntax highlighting via Monaco editor
• Full execution environment
• Session state preservation
• Visualization support where applicable
• Auto-completion and formatting

SQL First-Class Support

Write SQL once, execute across multiple databases:

SELECT user_id, COUNT(*) as activity_count
FROM events
WHERE date > CURRENT_DATE - INTERVAL 7 DAY
GROUP BY user_id
ORDER BY activity_count DESC
LIMIT 100;

Features:

• Connection picker to switch databases without editing code
• Query result pagination and export (CSV, JSON, TSV)
• Query cost estimation (BigQuery, Snowflake)
• Syntax highlighting for 10 SQL dialects
• Automatic optimization suggestions

Code Assistance

Intelligent code features without vendor lock-in:

• Auto-format (black, rustfmt, prettier, clang-format)
• Auto-documentation (Sphinx, JSDoc, Rustdoc)
• Auto-completion (LSP-based)
• Code templates for all languages
• Error detection and suggestions
• Performance analysis

Terminal Integration

Split terminals for complex workflows:

• Vertical splits (side-by-side panes)
• Horizontal splits (stacked panes)
• Up to 4 independent terminals
• Perfect for monitoring, logging, concurrent processes
• Useful for robotics, DevOps, data pipelines

Data Exploration

Visual data inspection without code:

• Click a file to see schema and statistics
• Automatic data quality scoring
• Column histograms and NULL detection
• PII detection (emails, phone numbers, SSNs)
• Data lineage tracking
• Filter and sort visually

---

Installation

macOS

brew install prismnote
prismnote

Linux

# Ubuntu/Debian
sudo apt-get install prismnote

# Fedora/RHEL
sudo dnf install prismnote

# Or from source
npm install -g prismnote
prismnote

Windows

# Using Chocolatey
choco install prismnote
prismnote

# Or via npm
npm install -g prismnote
prismnote

Docker

docker run -p 3000:3000 -v $(pwd)/notebooks:/app/notebooks prismnote:latest
# Open http://localhost:3000

From Source

git clone https://github.com/Mullassery/prismnote.git
cd prismnote
npm install
npm run dev
# Open http://localhost:3000

---

Quick Start

Create Your First Notebook

1. Start PrismNote: prismnote (opens http://localhost:3000)
2. Click "New Notebook"
3. Add cells by clicking "+" or pressing Cmd+Enter
4. Select language from dropdown
5. Write code and press Shift+Enter to execute

Try a Multi-Language Workflow

Cell 1 (Python): Load data

import pandas as pd
df = pd.read_csv('data.csv')
print(f"Loaded {len(df)} rows")

Cell 2 (SQL): Query database

SELECT * FROM analytics 
WHERE date > CURRENT_DATE - INTERVAL 30 DAY
ORDER BY timestamp DESC

Cell 3 (Python): Process results

# Continue working with results
print(df.describe())

Cell 4 (Markdown): Document findings

# Analysis Summary

Key findings:
- User count: 1,500
- Active rate: 78%

Keyboard Shortcuts

Common commands:

Cmd/Ctrl + Enter     Add cell
Shift + Enter        Execute cell
Cmd/Ctrl + K         AI assistance (if configured)
Cmd/Ctrl + S         Save notebook
Cmd/Ctrl + /         Toggle comment
Cmd/Ctrl + Shift + F Format code

---

Features by Language

Python

Full IPython kernel integration:

# Data analysis
import pandas as pd
df = pd.read_csv('data.csv')

# Visualization
import matplotlib.pyplot as plt
plt.plot(df['date'], df['value'])

# ML/AI
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

• Rich output (images, tables, HTML)
• Variable inspector
• Package installation (pip)
• Magic commands (%time, %timeit)

R

R kernel for statistical analysis:

library(tidyverse)

df <- read_csv('data.csv')

df %>%
  filter(value > 100) %>%
  mutate(normalized = scale(value)) %>%
  ggplot(aes(x = date, y = normalized)) +
    geom_line()

• ggplot2 visualization
• tidyverse data manipulation
• Statistical functions
• Package management

Julia

Julia kernel for numerical computing:

using LinearAlgebra
using Plots

A = rand(100, 100)
eigenvalues(A)

# Numerical computation
solve(A, rand(100))

• Multiple dispatch
• Parallel computing
• Scientific computing
• High performance

Rust

Compile and run Rust code:

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    for x in data {
        println!("{}", x * 2);
    }
}

• Safe systems programming
• Zero-cost abstractions
• Fast execution
• C/C++ interoperability

Go

Concurrent programming:

package main

func main() {
    ch := make(chan string)
    go func() {
        ch <- "Hello from goroutine"
    }()
    msg := <-ch
    println(msg)
}

• Goroutines and channels
• Fast compilation
• Production-grade
• Excellent stdlib

CUDA

GPU acceleration:

__global__ void add(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) c[i] = a[i] + b[i];
}

• NVIDIA GPU support
• Parallel computing
• High performance
• Deep learning acceleration

SQL

Multi-database support:

-- Works with PostgreSQL, MySQL, BigQuery, Snowflake, etc.
WITH ranked_users AS (
  SELECT user_id, score,
    ROW_NUMBER() OVER (ORDER BY score DESC) as rank
  FROM users
)
SELECT * FROM ranked_users WHERE rank <= 100;

• 9+ database backends
• Query optimization hints
• Cost estimation
• Result export

---

Workflows

Data Analysis Pipeline

1. Load Data (Python/SQL)

   import pandas as pd
   df = pd.read_csv('data.csv')
   

2. Explore Visually

   • Open Data Explorer
   • Click columns to see distributions
   • Identify patterns and outliers

3. Query Database (SQL)

   SELECT * FROM source_table WHERE conditions
   

4. Process Results (Python/R/Julia)

   • Clean data
   • Calculate metrics
   • Create visualizations

5. Document (Markdown)

   • Write findings
   • Embed visualizations
   • Record methodology

Systems Programming

1. Write Core Logic (Rust/Go/C++)

   fn process(data: &[u8]) -> Result<Vec<u8>, Error> {
       // High-performance code
   }
   

2. Benchmark

   import time
   start = time.time()
   # Run benchmark
   elapsed = time.time() - start
   

3. Test

   func TestMyFunction(t *testing.T) {
       // Test cases
   }
   

DevOps/Monitoring

1. Terminal 1: Monitor logs

   kubectl logs -f pod-name
   

2. Terminal 2: Watch metrics

   watch kubectl get pods
   

3. Terminal 3: Execute commands

   kubectl apply -f config.yaml
   

4. Terminal 4: Debug

   kubectl exec -it pod-name -- bash
   

---

Configuration

Database Connections

Configure in Settings (Cmd/Ctrl + ,):

{
  "database": {
    "type": "postgresql",
    "host": "localhost",
    "port": 5432,
    "database": "analytics",
    "user": "analyst"
  }
}

Supported databases:

• PostgreSQL (recommended)
• MySQL/MariaDB
• BigQuery
• Snowflake
• Amazon Redshift
• DuckDB (embedded)
• SQLite (file-based)
• SQL Server (T-SQL)
• Oracle Database

Code Formatting

Auto-format on save for all languages:

{
  "formatting": {
    "enabled": true,
    "formatOnSave": true
  }
}

Execution

Control how code runs:

{
  "execution": {
    "timeout": 30000,
    "maxOutputLines": 10000,
    "autoSave": true
  }
}

---

Keyboard Shortcuts

Core Operations

Shortcut	Action
Cmd/Ctrl + N	New notebook
Cmd/Ctrl + S	Save
Cmd/Ctrl + P	Command palette
Cmd/Ctrl + /	Toggle comment

Cells

Shortcut	Action
Cmd/Ctrl + Enter	Add cell
Shift + Enter	Execute cell
Cmd/Ctrl + Shift + Enter	Run all cells
Cmd/Ctrl + Delete	Delete cell

Navigation

Shortcut	Action
Cmd/Ctrl + F	Find in notebook
Cmd/Ctrl + G	Go to cell
Cmd/Ctrl + E	Data explorer

---

Performance

Benchmark results on typical workloads:

Language	Startup	1KB Code	1MB Data
Python	<1s	Fast	Fast
R	<2s	Medium	Fast
Julia	<3s	Very Fast	Very Fast
Rust	<2s	Very Fast	Very Fast
Go	<1s	Very Fast	Very Fast
SQL	<0.5s	Variable	Fast

Memory usage: ~45 MB baseline, scales with data size.

---

Documentation

Comprehensive documentation organized by topic:

🚀 Getting Started

• Installation & Setup - Quick start guide
• Multi-Language Support - Python, R, Rust, Go, etc.
• Multi-Terminal Guide - Split terminals tutorial
• Deployment Guides - Docker, AWS, Azure, GCP, Kubernetes

📚 Reference

• API Documentation - REST API endpoints
• Settings Reference - Configuration options
• Security - Security model and best practices
• Contributing - Contribution guidelines

🛠️ Development

• Product Vision - Strategic direction
• Features Status - Implemented vs planned
• Roadmap - Technical roadmap

🤖 AI & Integration

• Claude Integration - MCP protocol, Claude API
• Advanced Execution - Docker, Kubernetes backends

See Complete Documentation Index for all resources.

Troubleshooting

Python kernel not found

pip install jupyter ipython
# Restart PrismNote

R kernel missing

install.packages("IRkernel")
IRkernel::installspec()

Terminal commands not working

Check that commands exist in your PATH:

which python
which go
which rustc

High memory usage

• Restart kernel from settings
• Close unused cells
• Reduce data size
• Monitor with system tools

---

Use Cases

Data Science

• Exploratory data analysis
• Statistical analysis
• Machine learning workflows
• Data visualization
• Report generation

Systems Programming

• Algorithm development
• Performance optimization
• Concurrent system design
• Systems testing
• Benchmarking

Database Administration

• Query development
• Schema exploration
• Performance tuning
• Data migration
• Documentation

Education

• Teaching programming
• Lab assignments
• Interactive tutorials
• Code examples
• Student projects

Monitoring

• Real-time log analysis
• System status dashboard
• Alert investigation
• Trend analysis
• Performance debugging

---

Project Status

Version: 1.8.0
Status: Production Ready
License: Proprietary
GitHub: github.com/Mullassery/prismnote
Issues: github.com/Mullassery/prismnote/issues

Supported Platforms

• macOS (Intel, Apple Silicon)
• Linux (Ubuntu, Fedora, Debian)
• Windows (WSL2 recommended)
• Docker

Browser Support

• Chrome/Chromium 90+
• Firefox 88+
• Safari 14+
• Edge 90+

---

Architecture Highlights

Local-First Design

• Runs entirely on your machine
• No cloud account required
• All data stays local
• Works offline
• No bandwidth overhead

Multi-Language Engine

• Language-agnostic execution
• Jupyter kernel integration
• Direct compiler support
• Database driver abstraction
• Extensible architecture

Type-Safe Frontend

• TypeScript throughout
• React for UI
• Comprehensive testing
• Keyboard-accessible
• Performance optimized

---

Support & Resources

• GitHub Issues: Report bugs or request features
• GitHub Discussions: Ask questions and share ideas
• Releases: View changelog and download binaries
• Documentation: GETTING_STARTED.md and docs/

---

License

Proprietary Software - See LICENSE file for details

---

Next Steps

1. Install: npm install -g prismnote or brew install prismnote
2. Start: prismnote
3. Create: Your first notebook
4. Explore: Try different languages
5. Contribute: Help improve PrismNote

Questions? Visit github.com/Mullassery/prismnote/discussions

Enjoy data science and systems programming without boundaries.