For lectures and hands-on classes

One link
for the whole class.

A shared Python notebook, slides with handwritten notes and tasks where everyone answers on their own sheet. A student needs a browser and a name.

Open source under MIT. pip install colloq and the class runs on your own machine.

On your own serverNo sign-up to joinMaterials stay behind the link

Install · three commands

Install the package.
Send one link.

Colloq installs like any Python package and brings a class up on your own machine. Students need one link — no accounts, no Python to install.

pip install colloq
colloq start

a class on this machine

colloq start --share

one link for your students, while the terminal stays open

Documentation GitHub PyPI

Python · Node.js 22+ · Docker

01 / Class

Code on the projector.
Cursors from the whole room.

You open the notebook and the room works in it with you. Edits and run output are visible to everyone. Data you loaded into Python is there for the next cells — students’ cells too.

Maria runs cell 03 while Ivan finishes cell 04; Ivan’s run waits its turn in the room’s one kernel and gets the same df
The scene scrolls sideways →

02 / Lecture

Write on the slide.
Legible from the back row.

Upload a PDF, open the projection on the big screen and connect a tablet as the lecture console. Students see the slides and your handwriting in their own browsers.

Lecture console on a tablet

Pen, highlighter, eraser and pointer. Add a blank sheet to derive a formula; speaker notes stay with you.

Projector

The slide fills a separate window. Page through it with the arrow keys or a presentation remote, and show code from the notebook while you explain.

Student

Can go back a page, finish reading and catch up with one tap. The practice notebook is already open in the same room.

The teacher underlines η and writes “step size” on the console; the same ink and the red pointer appear on the projector, while a student finishes the previous page
The scene scrolls sideways →

The console is built for an iPad with Apple Pencil. Palm rejection and Split View are supported.

03 / Council New

One task.
Everyone writes —
their own answer.

Open a cell in Council. Every student writes on their own sheet: they do not see each other’s answers until you show one to the class.

  • 01You see who is still writing and who has submitted.
  • 02Every run is capped in time and goes through the one kernel.
  • 03The answer you pick is shown to the class, with or without the name.

The Oracle can draft a summary and replies. You decide what reaches the students.

Anna, Marat and Dina each write on their own sheet; their runs queue through the room’s one kernel, and nothing is shown to the class yet
The scene scrolls sideways →

Separate answers, one shared Python kernel. Students work on the data you prepared. Runs go one at a time; changes to shared objects and files can affect the answers that follow.

How a class starts

Teacher → room

Step 01 · Teacher

Prepare the room

Pick the format, the environment and the rules. Upload a PDF, start from an empty notebook or import materials from GitHub.

Step 02 · Student

Students join from the link

A student types a name and picks a mark. No email, no password, no Python on their computer.

Step 03 · The class

Run the class

Show slides, write code together or let everyone answer on their own. Afterwards the materials stay readable behind the same link.

A student types her name on the class link and joins the room: the count ticks up and the People panel shows who is doing what
The scene scrolls sideways →

Everything a class needs, in one room

The notebook, files, terminal and the Oracle live in the same room. The teacher decides who may use them.

One kernel

Two cells of the same notebook. You choose the order they run in.

Maria, student · cell 3

df = pd.read_csv("data.csv")
df.shape

You · cell 4

df["target"].mean()

An interactive sample: run Maria’s cell first, then yours. No Python runs on this page.

One document for everyone

People can edit the same cell at once. Cursors carry names, and edits show up for the whole room.

One kernel per room

A variable from cell three is there in cell four, whoever ran it. Output and the run queue are shared.

A shared terminal

Install a package once and the room has it. Commands run in the class environment.

The Oracle in the room

The assistant answers with the cells’ code and output in view. The whole room sees the questions and the answers. When you create a class you can leave it on hints only, or turn it off.

Shared files

Drag data in, sort files into folders. They are there from the notebook and from the terminal of the class.

Your own hardware

Run Colloq on your own computer or server. Different courses can get their own environments with the packages they need.

Room history

See who changed the code. The teacher can restore a cell or the whole notebook; Ctrl+Z undoes your own edits.

The Oracle edits a cell

Ask it to explain an error or propose an edit. The change is visible before you accept it, and you can discard it.

Room rules

Set who may edit, run code and upload files. After you end the class, students keep read access.

A student asks the Oracle to rewrite a cell: the question and the answer appear in the room’s shared thread, and the proposed edit can be accepted or discarded
The scene scrolls sideways →

Before your first class

Practical
questions

What is shared, what is kept, and where this tool stops.

What is left after the class?

The notebook, the files and the Oracle thread stay behind the same link. End class leaves students with reading, and keeps editing and runs for the teacher. You can resume the class; the notebook downloads as .ipynb.

What if someone deletes the code or starts an endless loop?

The teacher can interrupt the run, restore a cell from history, or restrict editing and running. Restarting the kernel clears the variables but keeps the notebook text and the files.

What if a student loses the connection?

The class goes on for everyone else. Edits kept in the browser sync once the connection is back. The same link brings the student into the room again.

Who sees the answers in Council?

A student sees their own answer, the teacher sees the room’s. To discuss one, the teacher can show it to everybody. The code runs in the shared kernel: this is a teaching format, not an isolated sandbox for grading exams.

Where does data go when the Oracle is used?

To the provider you configured: the question, the notebook and thread context, and the open file. In a Council review — the task and the submitted answers; in Act mode the assistant may read further files of the room. You choose the provider and set the limits.

You can point it at a local model through Ollama or vLLM. With no provider configured, the class simply runs without the Oracle.

Does it work for a remote class?

Yes, as long as the room can reach the server. Voice and video stay in whatever call service you use; the code, the slides and the tasks open in Colloq.

Can a whole course live here?

Colloq covers the class itself and its materials. Schedules, homework, grades and rosters stay in your own course system.

On your own machine

The course environment
stays under your control.

Colloq runs on a teacher’s laptop, a department server or a VPS. Python executes on that machine; students connect from a browser.

The source is open under MIT and the package is on PyPI. Python runs on your machine, and the class materials stay there too.

What you need

  1. 01
    A computer or a server

    Python, Node.js 22+ and Docker; resources to match the course.

  2. 02
    An address your room can reach

    A local network, your own domain or --share. Cloudflare addresses do not open from Russia — for those rooms you run your own relay.

  3. 03
    A model for the Oracle — optional

    An API from the provider you pick, or a local model.