JupyterLab does support real-time collaborative editing in the browser, as of a few weeks ago.

https://github.com/jupyterlab/rtc

Not that far, someone just needs to make a JupyterLab plugin that uses Automerge or a similar OT/CRDT structure for collaborative editing documents in a workspace (perhaps using WebRTC data channels for P2P sync between clients, or stick with the tried and true server model like Google docs). The trouble is turning that into something as polished and secure as Google Docs collaborative editing experience--there's a _lot_ of work to get there with tons of little corner cases, security issues (you're potentially giving strangers over the internet access to remotely run code in your browser--that should raise big alarm bells), etc. to think through. But the basic stuff is all out there for someone motivated to pick up and go wild with.

There is a PR to add initial support for real time collaboration in JupyterLite: https://github.com/jtpio/jupyterlite/pull/109

This reuses almost all the RTC work done upstream in JupyterLab itself.

And since this is implemented as a regular JupyterLab plugin, folks will then be able to swap it for something else and implement their own if they want to, as a federated extension.

Livebook does this! It only runs Elixir for now, but there is an issue to add other languages in future. It’s a really cool project IMO. https://github.com/elixir-nx/livebook

Doesn’t fufill your wish for no-sign up link yet, but https://hex.tech supports live collaboration for python notebooks.

I think as time goes on, live collaboration is becoming “table stakes” for a lot of tools.

We offer a collaborative notebook experience on https://iko.ai.

It's our internal machine learning platform that solves a bunch of our problems. We initially started building iko for internal because our projects took a toll on us.

- No-setup, fresh, notebook environments with the most popular libraries pre-installed.

- Real-time collaborative notebooks to see your teammates' changes live. Pair program, troubleshoot, and prototype together.

- Deploys your Streamlit application (we use this for prototypes to show clients so that a data scientist does not have to spin up a VM on GCP, install dependencies and environment, get the model, build the application, etc).

- Multiple notebook versions

- Leverage GPUs and schedule long-running notebooks that survive closed browsers and network disruptions. Watch your notebook's output as it runs from multiple devices.

- Automatic experiment tracking to detect your models, parameters, and metrics and saves them without you remembering to do so or pollute your notebook with tracking code. Know which parameters produced which model on which data.

- Easily deploy your model and get a "REST endpoint" so data scientists don't tap on anyone's shoulder to deploy their model, and developers can use the models without being dragged into the ML realm. You also can invoke it by entering data or uploading a CSV file.

- Build a Docker image for your model and push it to a registry (DockerHub or GitLab for now) to use it wherever you want

- Monitor your models' performance on a live dashboard and know if your model is losing its predictive power.

- Publish notebooks as AppBooks: automatically parametrize a notebook to enable clients to interact with it without being overwhelmed by code, or exporting as PDF, or building an application, or mutating the notebook.

More on our roadmap. We're only focusing on actual problems we have faced serving our clients, and problems we are facing now. This is not a "startup idea"; we're building what we need but we'd love to hear your thoughts and problems you have faced we may not be familiar with.