Sci REPL

×

SciREPL Help

Show the tour again

What’s new in this version

Header shortcuts: 📦 Browse and 🧭 Tour appear when there is room for them, so a narrow screen may leave them out; ∑ Formula is off by default. Choose Always, When there is room, or Never for each under Appearance → Header shortcuts, and set which one gives up its place first. Formula appears for Python code and Markdown cells.

Open-source licences

Quick Start — Python

# Basic math
2 + 2

# NumPy
import numpy as np
np.linspace(0, 10, 5)

# Plotly chart (interactive)
x = np.linspace(0, 2*np.pi, 50)
plot(x, np.sin(x))

# Matplotlib (install once, then use)
%pip install matplotlib
import matplotlib.pyplot as plt
plt.plot([1, 4, 2, 3])
plt.title("Matplotlib")
plt.show()

# SymPy (LaTeX rendering)
from sympy import symbols, sqrt, solve
a, b, c, x = symbols('a b c x')
solve(a*x**2 + b*x + c, x)

# Suppress output with ;
big_array = np.arange(1000);

Installing Packages

Install pure-Python packages from PyPI with %pip install:

%pip install requests

# Then use it
import requests
r = requests.get('https://api.github.com')
print(r.status_code)

Note: Only pure-Python packages are supported. Packages with C extensions (e.g. psutil) require pre-compiled WASM wheels.

Install R packages with install.packages() or %install:

# Standard R syntax (works out of the box)
install.packages("jsonlite")
library(jsonlite)

# Or use the %install shortcut
%install dplyr

Note: Only R packages compiled to WebAssembly are available. See repo.r-wasm.org for the package list.

Quick Start — R

Switch to R using the language selector. The webR runtime (~50 MB) downloads on first use and is cached.

# Basic math
mean(c(10, 20, 30))

# Vectors and stats
x <- rnorm(100)
summary(x)

# Static plot (PNG)
plot(1:10, (1:10)^2, main = "Quadratic")

# Interactive Plotly chart
plotly(1:50, sin(1:50 / 5), title = "Sine Wave")

# Multi-trace interactive chart
mplotly(
  traces = list(
    list(x = 1:10, y = (1:10)^2, name = "x²"),
    list(x = 1:10, y = (1:10)^3, name = "x³")
  ),
  title = "Power Functions"
)

# Cross-kernel file sharing
sharedfs_write("/shared/data/from_r.txt", "Hello from R!")
sharedfs_list("/shared/data")

Quick Start — Prolog

Switch to Prolog using the language selector (Py → PL).

% Assert facts
assert(parent(tom, bob)).
assert(parent(bob, ann)).

% Query
parent(tom, X).

% Rules
assert((grandparent(X,Z) :-
    parent(X,Y), parent(Y,Z))).
grandparent(tom, Z).

Shared Filesystem

SciREPL has a SharedVFS (shared virtual filesystem) that lets all kernels read and write to the same files. Files under /shared/ and /tmp/ are accessible from every language.

Directory layout:

• /shared/data/ — Datasets (CSV, JSON, etc.)
• /shared/lib/python/ — Python modules (auto-added to sys.path)
• /shared/lib/prolog/ — Prolog modules
• /shared/lib/wasm/ — WebAssembly modules
• /shared/bin/, /shared/config/ — Utilities and config files
• /tmp/ — Temporary files (shared, not persisted)

Per-kernel behavior:

• Python — Use standard open() with /shared/ paths. Files are synced to SharedVFS automatically after each cell execution.
• R — Use sharedfs_write() and sharedfs_read() helpers to access shared files.
• Prolog — Consult files from /shared/ paths directly.
• Bash — The brush-wasm shell has a built-in bridge to SharedVFS.

# Python — write a CSV to the shared folder
with open("/shared/data/results.csv", "w") as f:
    f.write("x,y\n1,2\n3,4\n")

# R — read it back
sharedfs_read("/shared/data/results.csv")

% Prolog — consult a shared knowledge base
:- consult('/shared/lib/prolog/kb.pl').

Packages, bundles & workbooks: When you install an item from Browse Packages, Bundles & Workbooks, bundle dependencies are installed first and files with /shared/ destination paths are written to SharedVFS automatically. Package files targeting a specific kernel (e.g., Prolog modules at /user/) go to that kernel's own filesystem.

Browsing files: Open Menu → Files & Storage to browse. Select SharedVFS from the dropdown to see shared files, or select a kernel (Python, Prolog) to see its internal filesystem. Use the Show empty folders checkbox to toggle visibility of empty directories.

Uploading: Use the "Upload File" button at the top of Files & Storage to upload files directly into SharedVFS. Set the destination path (default: /shared/data/) before uploading.

Export

Export Document — Choose a document format and image handling:

• HTML — Self-contained file with dark theme, code, and output. Choose "Separate files" for a .html.zip with an images/ folder.
• Markdown — Fenced code blocks, LaTeX math, and markdown tables. "Separate files" uses GitHub-compatible ![alt](images/X.png) references in a .md.zip.
• PDF — Opens the browser print dialog. Choose "Save as PDF" for a light-themed document.
• DOCX — Word document with code blocks, tables, images, and native Word equations (LaTeX math converted to editable OOXML formulas). Requires internet (library loaded on demand from CDN).
• LaTeX — .tex file for academic papers. Uses listings, amsmath, booktabs, graphicx. Exports as .tex.zip if images are present.

Export Workbooks & Packages — Export notebooks and data:

• .srwb (SciREPL Workbook) — Native format for saving and restoring your workspace. Can hold multiple tabs in one file (like Excel sheets). Preserves per-cell language, cell IDs, and all SciREPL-specific state. Use this to back up your work or move it between devices. Not readable by Jupyter or other tools.
• .ipynb (Jupyter Notebook) — Universal notebook format. One file per tab. Multi-language cells use %%magic commands (e.g. %%r, %%bash). Viewable in Jupyter, Colab, VS Code, and GitHub. Use this to share notebooks with others.
• Package — Archive (.zip/.tar/.tar.gz) containing notebooks and data files from SharedVFS. Use this to share an entire project with its datasets.

Syntax highlighting: Code cells display with syntax highlighting for Python, JavaScript, R, Bash, Prolog, and Lua. Exports (HTML, DOCX) also include highlighted code.

.ipynb import with outputs: When importing a .ipynb file that already contains outputs, they are displayed directly without re-executing the code. This allows fast viewing of notebooks from Jupyter, Colab, or previous SciREPL exports.

Quick Start — Lua

Switch to Lua using the language selector. The Fengari runtime (~200 KB) downloads on first use from CDN.

-- Tables (arrays and dictionaries)
t = {10, 20, 30}
print(#t, t[1])

-- Closures
function counter(start)
    local n = start
    return function() n = n + 1; return n end
end
c = counter(0)
print(c(), c(), c())

-- Coroutines
co = coroutine.create(function()
    for i = 1, 3 do
        coroutine.yield(i * i)
    end
end)
print(coroutine.resume(co))
print(coroutine.resume(co))

-- Pattern matching (built-in, no regex needed)
s = "Hello World 123"
print(s:match("(%a+)%s+(%a+)"))

-- Read another cell's output via Notebook VFS
prev = nb.read("In[1]", ".output")
print("Cell 1 said: " .. (prev or "(empty)"))

-- Write to a named cell (name a cell "results" first)
nb.write("results", ".code", "print('updated by Lua!')")

-- WARNING: overwrites the first cell's code!
nb.write("In[1]", ".code", "print('overwritten by Lua')")

Cross-Cell Communication (Notebook VFS)

Every cell is accessible as a virtual file at /nb/. You can read and write cell code, output, language, and name from any kernel. Cells can be addressed three ways:

• By name — /nb/my_cell/.code (user-assigned cell name)
• By index — /nb/In[1]/.code (1-based position)
• Relative — /nb/-1/.output (previous cell), /nb/+1/.code (next cell), /nb/./.code (self)

Properties: .code, .output, .language, .type, .name

Bash — uses filesystem paths directly:

# By name
cat /nb/my_cell/.code

# By index
cat /nb/In[1]/.output

# Relative: previous cell's output
cat /nb/-1/.output

# Self-reference
cat /nb/./.code

# Write to a cell
echo "print('hello')" > /nb/In[3]/.code

# List all cells
ls /nb/

Python — nb_read() / nb_write():

# By name
code = nb_read("my_cell", ".code")

# By index
output = nb_read("In[2]", ".output")

# Relative (previous cell)
prev = nb_read("-1", ".output")

# Write generated code to a named cell
nb_write("results", ".code", "print('generated!')")

# List all cells
cells = nb_list()

R — nb_read() / nb_write():

# By name
code <- nb_read("my_cell", ".code")

# By index
output <- nb_read("In[2]", ".output")

# Write to a named cell
nb_write("plot_cell", ".code", "plot(1:10)")

# List cells
cells <- nb_list()

Lua — nb.read() / nb.write():

-- By name
code = nb.read("my_cell", ".code")

-- By index
output = nb.read("In[2]", ".output")

-- Relative: previous cell
prev = nb.read("-1", ".output")

-- Write to a named cell
nb.write("results", ".code", "print('from Lua')")

-- List all cells (returns JSON)
cells = nb.list()

Prolog — nb_read/3 / nb_write/3:

%% By name
nb_read('my_cell', '.code', Code).

%% By index
nb_read('In[2]', '.output', Output).

%% Write compiler output to another cell
nb_write('r_factorial', '.code', GeneratedCode).

JavaScript — direct window.notebookVFS API:

// By name
const code = window.notebookVFS.readFile("/nb/my_cell/.code");

// By index
const out = window.notebookVFS.readFile("/nb/In[1]/.output");

// Write
window.notebookVFS.writeFile("/nb/In[3]/.code", "console.log('hi')");

Tip: Give cells a name (click the cell label) so other cells can address them by name instead of fragile index numbers.

Cell Language

Each cell remembers its language. To change a cell's language, click ✎ to edit, then use the language dropdown. Click All→ to apply the language to all code cells in the notebook.

Source-only Cells and TypR Directives

Put #!source on the first line of a named TypR or Lua cell to keep highlighted code available through the Notebook VFS without executing it. The remaining directives are TypR-specific:

• #!source — the cell shows Source only, intentionally has no Out [n], and remains readable through the Notebook VFS.
• #!typecheck — type-check the following code without executing it.
• #!transpile — show the transpiled R code.
• #!show-r — toggle generated R display for subsequent TypR executions.

Language Settings

Open Menu → Languages to show or hide languages in the cell dropdown. Unchecking a language removes it from the selector but doesn't unload its runtime. All languages are enabled by default. Your preferences are saved across sessions.

Runtime versions: R and Prolog show the tested default, latest available, current selection, and successfully loaded session source separately. Leave the version and source fields blank to use the exact tested default. R accepts a webR tag such as v0.5.4; latest is rolling and unverified. Prolog accepts a compatible npm-swipl-wasm selector such as 3/8/2; its global latest is an incompatible package line and is rejected, so use Check latest for the newest compatible 3.x release. Changes require a reload.

Keyboard Shortcuts

• Shift+Enter or Ctrl+Enter — Run code
• Ctrl+F / Cmd+F or 🔍 button — Find in notebook (with replace)
• Tab — Insert 4 spaces
• ; at end of line — Suppress output

Documentation

Full documentation: GitHub README

Version

SciREPL

Includes: Multi-language (Python, R, Prolog, Bash, JavaScript, Lua), editable cells, markdown cells, session persistence with auto-save and crash recovery, Math Mode palette, .ipynb import/export with output preservation, .srwb workbook format, rich export (HTML, Markdown, PDF, DOCX with native equations, LaTeX) with syntax highlighting, virtual filesystem, search paths, URL file fetching, multi-notebook support, package catalog with one-click install, language settings, package format (.zip/.tar.gz)

Privacy

Privacy Policy

×

Cell Name

Enter a name for this cell (empty to clear):

×

Menu

×

Close final workbook?

Don’t show this explanation again

×

Export Notebook

×

Export Workbooks & Packages

×

Settings

×

Appearance

Space above the header, so the app does not sit under the device status bar. Auto follows the device's reported safe area. Set 0 to remove it entirely.

Scales the header buttons. Larger buttons are easier to hit on a touchscreen.

Keep frequently used tools in the header. Hidden shortcuts can be re-enabled here at any time.

Only languages with a usable translation are listed. File extensions and kernel names stay in their original form in every language.

×

Languages

Enable or disable languages in the cell dropdown.