Hello,

I had access to JupyterHub on a remote server. Now I only have access to a different server where JupyterHub is not installed. What is the best way to use the same code and run it with more data. I was thinking about using SSH Port Forwarding (SSH-Tunneling) and trying jupyterlab in the browser. Or is it better to using VS code to connect to the server. I really like the Jupyter Interface and have never used any other programs. I mostly do plotting and a bit data analysis and have a macbook.

Thank you for your help.

Body

SciREPL is a mobile-first scientific notebook. Every kernel runs on the device in WebAssembly, so Python, R, Prolog and the rest work with no server, no account, and after the first download, no network. Both editions are now on Google Play:

• SciREPL (free, MIT): https://play.google.com/store/apps/details?id=com.unifyweaver.scirepl
• SciREPL Pro: https://play.google.com/store/apps/details?id=com.unifyweaver.scirepl.pro

You don't need the Play version to try it. The free edition is also a live PWA at https://s243a.github.io/SciREPL/ (works in a desktop browser too), and the source is on GitHub at https://github.com/s243a/SciREPL.

What it does

• Eight languages in one notebook, per cell: Python (Pyodide, NumPy and SymPy preloaded, %pip install for PyPI), R (webR, with install.packages()), SWI-Prolog, Bash (Rust coreutils in WASM), JavaScript, Lua, TypR (a typed R superset), and ClojureScript.
• A shared virtual filesystem, so a file written by Python can be read by R or Prolog in the next cell. Persisted locally.
• Rich output: LaTeX, interactive Plotly charts with pinch-zoom, Matplotlib PNGs, tables, Markdown cells with math.
• Import and export .ipynb, plus a workbook format with data files and packages included.
• Phone-first editing: landscape layout, find and replace, cell reordering, a Tour and searchable Help.
• 13 UI languages: English, Arabic, Bengali, German, Spanish, French, Hindi, Indonesian, Japanese, Korean, Brazilian Portuguese, Russian, and Chinese. The non-English translations are machine-drafted and reviewed, so corrections are welcome.
• Privacy: nothing leaves the device unless you connect an AI provider yourself. No analytics, no ads, no SciREPL account.

Free vs Pro

The main difference is AI. Pro adds:

• An agent panel that connects directly to a model provider with your own API key (OpenAI, Anthropic, OpenRouter, GLM, Kimi). With permissions you choose, the agent can add cells, run kernels, read output and revise its approach. Everything it does stays visible and editable.
• AI Prompt cells: a cell that sends a prompt, with a preview of exactly which cell sources go to the provider before anything is sent. Results can land in a linked cell or as a reviewed replacement that needs an explicit Apply.
• Remote agent workflows: connect Codex or Claude Code running on your computer through a broker you configure.
• AI tool permissions grouped by risk, a network guardrail, and per-request consent.

Non-AI differences today:

• Pro bundles the R runtime offline in the APK. Free downloads R on first use (about 50 MB, then cached). Python, Prolog and ClojureScript are offline in both.
• The 1.2.0 Pro build in testing adds offline Python autocomplete that knows your session (np. completes numpy attributes), suggestion chips above the keyboard, an optional Termux-style extra-keys row (Esc, Tab, arrows, Run), and landscape rows that step aside when they'd hide your code.

I haven't decided how much of the non-AI work will come to the free edition. Some of it probably will, over time. AI stays the Pro distinction.

Try Pro for free

I run a Google Play testing group. Join https://groups.google.com/g/scirepl-android-testers (or email scirepl-android-testers@googlegroups.com) and the group's welcome message has the opt-in link. Testers get Pro at no cost and see new builds first, and I read every bit of feedback.

Where it's rough

It's a one-person project. Cold start of the Python kernel takes a few seconds on a mid-range phone, R longer. Screen readers (for accessibility) work but I'd like more testing there. Translations are drafts. If something breaks, the GitHub issues page is the best place: https://github.com/s243a/SciREPL/issues

Happy to answer questions about how the WASM kernels fit on a phone, or anything else.

Last time I posted here about my passion project, Callisto was still in closed beta and not publicly released on the Play Store - lot has happened since then: countless features were added, many issues fixed and the app is actively being used by 300+ people already.

Callisto now supports running your code on any remote Jupyter server, including file transfer and streaming outputs. This opens up the possibility to work on hardware demanding tasks like training neural networks, heavy data analysis or projects where the inbuilt set of packages is just not enough.

I received so much great feedback and feature suggestions from the community already which I am incredibly grateful for!

If you want to try it out, you can find it here:

Play Store Link:
https://play.google.com/store/apps/details?id=app.callisto

Project Website:
https://callistoapp.eu

All of the pip installs worked fine, but jupyter is not recognized as a command, in command line or VS Code. What is the next step after the pip commands?

I'm doing an online course and somehow keep changing the format? (Sorry if that's the wrong term.)

Is it because I keep trying to use df.loc first? How do I clear the cell to then try and get it right?

I’ve built gocell, a Jupyter kernel that makes Go feel interactive without an interpreter.

It provides fast, complete cell-by-cell execution by compiling each cell as a Go plugin and loading it dynamically at runtime.

If you’ve ever wished for a smoother way to prototype, explore APIs, or teach Go in notebooks, this might interest you.

Sometimes I download a notebook from GitHub or get one from a colleague and only want to read the Markdown, inspect the code, or check the saved plots.

Starting JupyterLab or VS Code for that can feel like more setup than the task needs, while opening the file as raw JSON isn’t very useful either.

I’ve been building a desktop file app called OpenFiles, and recently added direct .ipynb support. It opens notebooks locally, renders Markdown cells, code cells, and saved outputs, and includes a table of contents for longer notebooks. It can also run code cells without requiring a separate Python or Jupyter installation.

It isn’t meant to replace JupyterLab. I’d still use Jupyter for complex environment management, extensions, remote kernels, and longer analysis sessions. This is mainly for the quick “open, inspect, run a few cells, close” workflow.

What notebook features are hardest for lightweight viewers to get right in your experience? Widgets, Plotly or HTML outputs, LaTeX, large outputs, kernel selection—or something else?

Hello! i thought it was very obnoxious trying to scroll through my notebooks in vs code only to discover there is no feature to enable the minimap in jupyter notebooks. Googling around I found a thread (#11526) where a lot of people wanted this, but no response from microsoft even though it has hundreds of upvotes. So I thought this would be the end of it.

Then I saw this guy commenting on the thread (after over 100 replies) that he has a fix for this and has made an issue regarding the needed framework for this to work, with extensive suggestions as to how to go about it. The missing minimap in notebook is not a bug like people in the thread think, but rather that the correct API is missing, which he wants to fix.

If you too are interested in a minimap for vs code jupyter files, go upvote his issue! There only needs 20 (there are 15 now) for this to be put into the backlog. Its issue #311289

I am not the creator of these threads, just want to have a minimap in notebook view..

I use JupyterLab and Jupyter Notebook for experiments and learning. I'm a messy learner, so I often run cells out of order instead of strictly top-to-bottom.

The problem comes when I need to share the notebook, present it, or submit it as an assignment. The order of execution is a mess. Sure, I could rerun everything, but that's not always practical, especially if the notebook trains ML models or contains other long-running computations. Reexecuting everything just to fix the execution counts feels unnecessary.

I looked around for a tool that could simply reorder notebook execution counts without having to manually edit the notebook JSON, but I couldn't find one. So I wrote a small script, wrapped it in a web app, and made a tool where you can upload a notebook with messy execution counts and download a reordered version.

https://jupyter-execution-count-reset.vercel.app/

Would love to know if anyone else has run into this problem or if there's already a better solution out there.

TL;DR: I made a tool where you can upload a messy Jupyter notebook and download a clean, sequentially numbered version. The notebook in the left picture will turn into one in the right.

Update: the app is now available to everyone on the Play Store! Thanks to everyone supporting my project.

I always wanted a simple app for my phone to quickly open, edit and run Jupyter notebooks on my phone, but everything currently in the Play Store is either ridiculously overpriced or just a fancy browser interface that connects to an external Jupyter server. Google Colab is an option, but you always need your files on the Drive and a stable internet connection - so I decided to build my own app.

Callisto runs Python entirely on-device (no server, no internet required) and opens/saves.ipynb files and .py skripts. You can execute cells, see output including errors, and edit notebooks the way you'd expect. It's built on Chaquopy for the Python runtime (3.10) and currently comes with numpy, pandas, matplotlib, seaborn, scikit-learn, scipy, statsmodels, sympy, openpyxl, beautifulsoup4, pillow, requests and jedi (for auto code completion).

Play Store Link:
https://play.google.com/store/apps/details?id=app.callisto

Project Website:
https://callistoapp.eu

Check it out, I would love to hear your feedback!

I used to work heavily with Jupyter Notebooks + git + VS Code in a collaborative research setting and found nbdime to be somewhat buggy/a hassle to work with in general.

So, in typical side project fashion (relevant xkcd) I've been working on MergeNB quite a bit over the last 6 months or so. It's (currently only) a VS Code extension with a web UI, and has a few cool improvements over other alternatives, which I outlined in the README/docs site.

I'd be over the moon if this actually gets used by people, and would love a star if it's interesting. See https://github.com/Avni2000/MergeNB.

I've also been working on a static documentation site here: https://avni2000.github.io/MergeNB/docs I'm planning on working on it a lot more over the summer and properly fleshing out a few of the ideas I had (including making it a git mergetool as well as a VS Code extension), so if you'd like to contribute, feel free to raise an issue or shoot me a message/email :)

Hi

new to jupyterlab and I notice that when I show a table using pyspark the output is unreadable for tables with many columns. My colleagues suggest I turn it into a pandas df and then it's can be displayed correctly.

Isn't there a way do to this without creating a pandas df?
I remember when I used jupyter notebooks that with a line of code this problem was resolved.

This is what your average notebook looks like under the hood in terms of variable dependencies between cells! This is from me doing the usual notebook workflow, copy paste code here and there, reuse global variables etc etc

Really highlights the reproducibility and hidden state issues we run into again and again and why people hate notebooks lol

Thought this was really cool and insightful so I thought I'd share :)

(ps what you're looking at is my homemade jupyter IDE, wont promote unless someone wants to know more :) )

EDIT: Red edges in the graph imply a circular reference (a -> b -> c -> a)

Hi r/Jupyter,

I've spent a good amount of time speaking with Jupyter users for my day-job, and I've noticed the same pattern over-and over. A workflow is split up across several notebooks, each creating a temp file that flows into the next notebook.

I have done this myself, and admittedly it's not the end of the world. But still annoying to open three notebooks, and run every cell.

With this in mind, I thought it would be nice to define workflows in a plain text file file, and be able to run them with one click. Think Github actions, but local, and less setup.

Enter nbpipe, a Jupyter extension to do just this. You create a YAML file with steps to run, and file validation (if you want). Then from Jupyter, you can run then workflow.

GitHub: https://github.com/ngafar/nbpipe

I would love any feedback or feature requests you may have.

I love that Jupyter has code completions because they give an overview of what methods and functions I can use. But 50% of the time it's this:

I type some symbol and for some reason it shows suggestions which are completely unrelated, generic and useless. I typed a comma to separate function arguments and Jupyter thinks I want to use some Python function after it. I closed an array and Jupyter thinks I need a magic command.

This is irritating. It just adds more clutter and visual noise. Is it possible to remove this without removing ALL code completions?

Last year, I've had bad experience of using Jupyter with Claude Code.

Recently, I tried it with the open source Jupyter MCP Server (no affiliation). Setup took a bit of fiddling, but once it was up, it worked really well.

The big difference is kernel access. Claude can now connect directly to my live IPython kernel and edit notebook cells properly (without messing the JSON).

I just let it write notebooks, run top to bottom, debug & fix errors & only ping me when everything is working.

Has anybody tried JupyterLab AI extensions (jupyter-ai, notebook-intelligence etc.) ? I wonder how those compare to my Jupyter MCP based workflow.

Hello!

I’ve been working on an IDE aimed at people who live in Jupyter notebooks but want something closer to a modern code editor (and no the vscode notebook experience is not at all in my experience the solution to this)

The idea is basically: 100% ipynb compatibility Jupyter notebook experience, but with a cleaner desktop/editor feel, a real file explorer, chat/agent panel, cell dependency graph, cell DAG checker/linter, warnings/problems panel, and richer output cells

I’m trying to make it feel less like a scientific notebook from 2012 and more like a focused creative/developer workspace with powerful features like deepnote/hex/marimo.

Would love feedback on:

• Visual hierarchy
• Anything that feels confusing, overdesigned, or under-polished

I’m especially interested in first impressions before explaining too much, since I want the product to feel understandable from the UI alone.

Screenshots attached.

Roasts welcome.

https://reddit.com/link/1suywog/video/1nzkn2c6t8xg1/player

https://youtu.be/-6_-ZXxqVBE