What it does

Instead of just chatting about code, the Coding Agent can directly edit your files. Ask it to fix a bug, refactor a function, or add error handling, and it responds with precise, line-level edits that you review as diffs before applying.

Key features

• Works everywhere — Python, R, Julia, JavaScript/TypeScript, C/C++, HTML, Markdown, and many more file types, plus Jupyter notebooks.
• Context-aware — The agent sees your cursor position, selected text, and surrounding code. No need to copy-paste context manually.
• Safe edits — Either trust it via auto-accepting and revert using TimeTravel, or review all changes.
• Shell commands — The agent can suggest terminal commands (install packages, run tests) that you confirm before execution.
• Jupyter integration — In notebooks, the agent can create, edit, and run cells. Use the "Generate" button between cells or per-cell tools (Explain, Fix, Modify) to open the agent with context pre-filled.
• Session history — Conversations are organized into "turns". You can revisit, rename, or start fresh.
• Cost estimation — See estimated token usage before sending each message.

Open the Assistant tab in the side chat panel of any code file or notebook to get started.

LaTeX Agent

Similar to Jupyter and Code, there is also an Assistant tab in a .tex files. It understands LaTeX document structure and applies edits that keep your document valid.

LaTeX-specific capabilities

• Environment-aware edits — When a change touches a theorem, proof, align block, or math environment, the agent includes enough surrounding context to ensure the result is syntactically valid.
• Minimal but correct — Edits are as small as possible, but never at the cost of leaving broken LaTeX.
• Instant error fixing — When a LaTeX build fails, click "Help me fix" in the error gutter — the agent analyzes the error and proposes a fix. Enable auto-accept edits and compilation errors get resolved almost instantly: click, fix, done.

This works alongside CoCalc's existing LaTeX build system, and with enabled auto-build on save, this has the potential to speed up your work with LaTeX significantly.

Open any .tex file and switch to the Assistant tab to try it out.

There will also be very early unstable alpha releases of CoCalc Launchpad at [2], which is a multiuser version of CoCalc, which requires connecting external VM's for running code.

Email help@cocalc.com and asked to be added to the official alpha testers group if you want more details, guidance, and to provide feedback.

[1] https://software.cocalc.ai/software/cocalc-plus/index.html

[2] https://software.cocalc.ai/software/cocalc-launchpad/index.html

[3] https://github.com/sagemathinc/cocalc-ai

Here is a simple demo example:

Which indeed modified a file in my project:

What is this? It's a locally installable version of CoCalc that does NOT require Docker, and lets you fully use whatever Jupyter kernels, latex, etc. you have on your own laptop directly. It's a single self-contained binary, and is very lightweight.

Try it, with the caveats of course that it's probably horribly broken.

• There is an Apple Silicon mac binary that is properly signed.
• There's a Linux binary for x86_64 as well.

Most importantly, this is the first version of CocalcPlus ever that actually has AI support, which was a significant amount of work to add. To configure AI, click on the settings icon in the UPPER RIGHT, then click on "AI" and paste in a key and click save. You might need to refresh your browser, but you'll get full AI integration for the provides you configure.

You can also run this on a remote server and thus use the CoCalc UI, TimeTravel, Jupyter notebooks, whiteboards, latex editor, terminals, etc., and thus more easily use that remote server.

The design is very lightweight in that it is single user and there is only one project -- your computer. There is also no separate database.

This does not currently support integration with cocalc.com, but that is of course planned soon as an option. The model is that CoCalc+ will be free, but some integrations with our cloud services will require a subscription.

https://github.com/sagemathinc/cocalc/discussions/8651

https://pypi.org/project/cocalc-api/

and you should be able to pip or uv install it as normal.

The docs are at

https://cocalc.com/api/python/

You might want to try a few basic things like:

• create an api key in account prefs on cocalc (refresh your browser if you get an error setting the expire date, since I just fixed an issue)
• use the api to list your projects,
• create a project,
• copy files between two projects

Organizations

CoCalc now has a notion of organizations with admins, who can manage users of an organization. This is currently only accessible via this Python API right now. It is designed to make it much easier to build things like asynchronous courses involving Jupyter notebooks, where you want to easily build your own custom workflow and user management instead of using CoCalc's course management UI.

For managing users we will need to create a new "organization" for you and make you an admin of that organization. You can then create users in your org, provide a URL so they can use cocalc (without having to worry about creating accounts themselves), etc. Can you also make projects for them, add them as collaborators to those projects, copy files to their projects (from your own template project), list all members of your org, etc. It's also easy to broadcast a message to all org members.

It's also fairly easy to add new functionality to this API. What is missing that you want? An obvious gap is compute servers, right now.

-- William

Existing projects are unaffected. If you want to switch, you can do this any time via Project Settings → Project Control → Software Environment.

To see what’s included, check out our software inventory.

Programming Languages and Features

• Python: There is now a new "CoCalc Python" environment, featuring a curated set of popular packages. This replaces the previously called "system-wide" environment. Terminals now run inside this environment by default. The main benefit is, that this allows to manage Python packages without depending on system-wide packages, installed for system utilities. As before, you can also use the Anaconda-based environment via anaconda2025, and we continue to offer a Colab-compatible environment.

• R: We now provide a broader selection of R packages, powered by r2u, making it easier and more convenient to get started.

• SageMath: The latest version of SageMath is available in the new environment. For earlier SageMath releases, please switch to the "Ubuntu 22.04" environment.

• LaTeX: This is now running a full and up-to-date Texlive distribution. We plan to update its packages with each new software environment update.

This week, NVIDIA highlighted CoCalc as a key platform for teaching with its CUDA-Q academic materials. In their technical blog post, NVIDIA mentions how CoCalc can provide a seamless learning environment for the next wave of quantum computing specialists.

This might also be a good time to add that we were officially accepted as an NVIDIA Inception Program Member a while back!

Our Chief Sales Officer, Blaec Bejarano, has had the pleasure of meeting Monica Van Dieren, a Senior Technical Marketing Engineer at NVIDIA, at the Joint Mathematics Meeting in Seattle this past January. Their discussions continued at the NVIDIA GTC conference in San Jose in March, solidifying our shared vision for accessible and powerful quantum computing education.

NVIDIA's CUDA-Q Academic program is a comprehensive suite of Jupyter notebooks designed to bridge the gap between theoretical quantum mechanics and practical application. These resources are now readily available via CoCalc, allowing students and instructors to dive into complex topics like quantum machine learning and variational algorithms without the hassle of a complex setup.

The synergy between CoCalc's collaborative platform and NVIDIA's cutting-edge educational content creates an unparalleled learning experience. Students can work through CUDA-Q modules, leveraging CoCalc's powerful computational resources and real-time collaboration features. This integration is particularly highlighted in NVIDIA's post, which notes the ease of getting started on platforms like CoCalc.

For those eager to explore these resources, the CUDA-Q Academic GitHub repository is the perfect starting point: https://github.com/NVIDIA/cuda-q-academic/tree/main?tab=readme-ov-file

We are thrilled to be at the forefront of education, providing the tools necessary to train the quantum workforce of the future. The journey with NVIDIA is just beginning, and we look forward to empowering more learners around the globe.

This new functionality is the result of extensive discussions with many teachers who are already using CoCalc in the courses, and want to expand their classes to gives students real experience involving AI, deep learning and more using state of the art GPU's.

https://youtu.be/ikktaiw14Tw?si=_a6HxTRgDeN2NrVg

https://youtu.be/Kx_47fs_xcI?si=99Ex4yNQ14IVzkmD

Transforming Physics Understanding Through Computation

Physics—the study of matter, energy, and their interactions—has always been deeply mathematical. Today, computational methods have become essential tools for understanding complex physical phenomena that resist analytical solutions. CoCalc provides an ideal environment for learning physics through the powerful combination of theoretical understanding and computational exploration.

For information about available scientific computing tools and environments, see the CoCalc documentation.

Whether you're modeling planetary motion, analyzing quantum systems, or exploring electromagnetic fields, CoCalc's integrated tools help you visualize, simulate, and understand the physical world in ways that traditional methods alone cannot achieve.

Your Computational Physics Toolkit

Python for Physics: The Foundation

Python has become the lingua franca of computational physics, offering powerful libraries and intuitive syntax:

# Essential physics imports
import numpy as np
import matplotlib.pyplot as plt
from scipy import integrate, optimize
import sympy as sp

# Welcome to computational physics!
print("Welcome to Computational Physics with CoCalc!")

# Physical constants (in SI units)
c = 299792458          # Speed of light (m/s)
h = 6.62607015e-34     # Planck constant (J⋅s)
hbar = h / (2 * np.pi) # Reduced Planck constant
k_B = 1.380649e-23     # Boltzmann constant (J/K)
e = 1.602176634e-19    # Elementary charge (C)
m_e = 9.1093837015e-31 # Electron mass (kg)
m_p = 1.67262192369e-27 # Proton mass (kg)

print(f"Speed of light: {c:.0e} m/s")
print(f"Planck constant: {h:.3e} J⋅s")
print(f"Electron mass: {m_e:.3e} kg")

Mechanics: Motion and Forces

Start your physics journey with classical mechanics:

# Classical mechanics: projectile motion
def projectile_motion():
    """
    Simulate projectile motion with air resistance
    """
    
    # Parameters
    g = 9.81          # Gravitational acceleration (m/s²)
    v0 = 50           # Initial velocity (m/s)
    angle = 45        # Launch angle (degrees)
    m = 1.0           # Mass (kg)
    b = 0.1           # Air resistance coefficient
    
    # Convert angle to radians
    theta = np.radians(angle)
    
    # Initial conditions
    vx0 = v0 * np.cos(theta)
    vy0 = v0 * np.sin(theta)
    
    # Differential equation: F = ma = -mg - bv
    def equations_of_motion(t, state):
        x, y, vx, vy = state
        
        # Air resistance force
        v_magnitude = np.sqrt(vx**2 + vy**2)
        if v_magnitude > 0:
            ax = -b * vx * v_magnitude / m
            ay = -g - b * vy * v_magnitude / m
        else:
            ax = 0
            ay = -g
        
        return [vx, vy, ax, ay]
    
    # Solve the differential equation
    t_span = (0, 10)
    initial_state = [0, 0, vx0, vy0]
    
    # Event function to stop when projectile hits ground
    def hit_ground(t, state):
        return state[1]  # y-coordinate
    hit_ground.terminal = True
    hit_ground.direction = -1
    
    solution = integrate.solve_ivp(
        equations_of_motion, t_span, initial_state,
        events=hit_ground, dense_output=True, rtol=1e-8
    )
    
    # Extract trajectory
    t_flight = solution.t
    trajectory = solution.y
    
    # Plot trajectory
    plt.figure(figsize=(10, 6))
    plt.plot(trajectory[0], trajectory[1], 'b-', linewidth=2, label='With air resistance')
    
    # Compare with no air resistance (analytical solution)
    t_no_air = np.linspace(0, t_flight[-1], 100)
    x_no_air = vx0 * t_no_air
    y_no_air = vy0 * t_no_air - 0.5 * g * t_no_air**2
    
    plt.plot(x_no_air, y_no_air, 'r--', linewidth=2, label='No air resistance')
    
    plt.xlabel('Horizontal Distance (m)')
    plt.ylabel('Height (m)')
    plt.title(f'Projectile Motion (v₀={v0} m/s, θ={angle}°)')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()
    
    # Calculate range
    range_with_air = trajectory[0][-1]
    range_no_air = v0**2 * np.sin(2*theta) / g
    
    print(f"Range with air resistance: {range_with_air:.1f} m")
    print(f"Range without air resistance: {range_no_air:.1f} m")
    print(f"Air resistance reduces range by: {(1 - range_with_air/range_no_air)*100:.1f}%")
    
    return t_flight, trajectory

# Execute projectile motion simulation
time, trajectory = projectile_motion()

Oscillations and Waves

Explore periodic motion and wave phenomena:

# Simple harmonic motion and damped oscillations
def harmonic_oscillator():
    """
    Study simple harmonic motion and damping effects
    """
    
    # Parameters
    omega_0 = 2.0     # Natural frequency (rad/s)
    gamma = 0.1       # Damping coefficient
    F0 = 1.0          # Driving force amplitude
    omega_d = 1.8     # Driving frequency
    
    # Equation of motion: m*x'' + gamma*x' + k*x = F*cos(omega_d*t)
    # Using omega_0^2 = k/m, we get: x'' + gamma*x' + omega_0^2*x = (F0/m)*cos(omega_d*t)
    
    def oscillator_equation(t, state):
        x, v = state
        
        # Driving force
        driving_force = F0 * np.cos(omega_d * t)
        
        # Acceleration
        a = -2*gamma*v - omega_0**2*x + driving_force
        
        return [v, a]
    
    # Time array
    t = np.linspace(0, 20, 1000)
    
    # Solve for different initial conditions
    solutions = {}
    initial_conditions = [
        (1.0, 0.0, "x₀=1, v₀=0"),
        (0.0, 2.0, "x₀=0, v₀=2"),
        (0.5, 1.0, "x₀=0.5, v₀=1")
    ]
    
    plt.figure(figsize=(12, 8))
    
    for i, (x0, v0, label) in enumerate(initial_conditions):
        solution = integrate.solve_ivp(
            oscillator_equation, (0, 20), [x0, v0],
            t_eval=t, rtol=1e-8
        )
        
        solutions[label] = solution
        
        plt.subplot(2, 2, i+1)
        plt.plot(solution.t, solution.y[0], 'b-', linewidth=1.5)
        plt.xlabel('Time (s)')
        plt.ylabel('Position (m)')
        plt.title(f'Damped Oscillator: {label}')
        plt.grid(True, alpha=0.3)
    
    # Phase space plot
    plt.subplot(2, 2, 4)
    for label, solution in solutions.items():
        plt.plot(solution.y[0], solution.y[1], linewidth=1.5, label=label)
    
    plt.xlabel('Position (m)')
    plt.ylabel('Velocity (m/s)')
    plt.title('Phase Space')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    # Analyze frequency response
    frequencies = np.linspace(0.1, 4.0, 100)
    amplitude_response = []
    
    for omega in frequencies:
        # Steady-state amplitude for driven oscillator
        amplitude = F0 / np.sqrt((omega_0**2 - omega**2)**2 + (2*gamma*omega)**2)
        amplitude_response.append(amplitude)
    
    plt.figure(figsize=(10, 6))
    plt.plot(frequencies, amplitude_response, 'r-', linewidth=2)
    plt.axvline(omega_0, color='b', linestyle='--', alpha=0.7, label=f'ω₀ = {omega_0}')
    plt.xlabel('Driving Frequency (rad/s)')
    plt.ylabel('Steady-State Amplitude')
    plt.title('Frequency Response of Damped Harmonic Oscillator')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()
    
    return solutions, amplitude_response

# Execute oscillator analysis
oscillator_solutions, frequency_response = harmonic_oscillator()

Electromagnetism: Fields and Forces

Explore electric and magnetic phenomena:

# Electromagnetic field visualization
def electromagnetic_fields():
    """
    Visualize electric and magnetic fields
    """
    
    # Electric field of point charges
    def electric_field_point_charges():
        """Visualize electric field of multiple point charges"""
        
        # Define point charges: (x, y, charge)
        charges = [
            (2, 2, 1.0),    # Positive charge
            (-2, -2, -1.0), # Negative charge
            (0, 3, 0.5),    # Smaller positive charge
        ]
        
        # Create grid
        x = np.linspace(-4, 4, 20)
        y = np.linspace(-4, 4, 20)
        X, Y = np.meshgrid(x, y)
        
        # Calculate electric field
        Ex = np.zeros_like(X)
        Ey = np.zeros_like(Y)
        V = np.zeros_like(X)  # Electric potential
        
        k = 8.99e9  # Coulomb constant (N⋅m²/C²)
        
        for charge_x, charge_y, q in charges:
            # Distance from each grid point to the charge
            dx = X - charge_x
            dy = Y - charge_y
            r = np.sqrt(dx**2 + dy**2)
            
            # Avoid division by zero
            r = np.where(r < 0.1, 0.1, r)
            
            # Electric field components
            Ex += k * q * dx / r**3
            Ey += k * q * dy / r**3
            
            # Electric potential
            V += k * q / r
        
        # Plot electric field and equipotential lines
        plt.figure(figsize=(12, 5))
        
        # Electric field vectors
        plt.subplot(1, 2, 1)
        plt.quiver(X, Y, Ex, Ey, np.sqrt(Ex**2 + Ey**2), cmap='viridis', alpha=0.7)
        
        # Mark charge locations
        for charge_x, charge_y, q in charges:
            color = 'red' if q > 0 else 'blue'
            size = abs(q) * 100
            plt.scatter(charge_x, charge_y, c=color, s=size, edgecolors='black')
        
        plt.xlabel('x (m)')
        plt.ylabel('y (m)')
        plt.title('Electric Field')
        plt.axis('equal')
        plt.colorbar(label='Field Magnitude')
        
        # Equipotential lines
        plt.subplot(1, 2, 2)
        contour = plt.contour(X, Y, V, levels=20, colors='blue', alpha=0.6)
        plt.clabel(contour, inline=True, fontsize=8)
        
        # Mark charge locations
        for charge_x, charge_y, q in charges:
            color = 'red' if q > 0 else 'blue'
            size = abs(q) * 100
            plt.scatter(charge_x, charge_y, c=color, s=size, edgecolors='black')
        
        plt.xlabel('x (m)')
        plt.ylabel('y (m)')
        plt.title('Electric Potential')
        plt.axis('equal')
        
        plt.tight_layout()
        plt.show()
        
        return X, Y, Ex, Ey, V
    
    # Magnetic field of current loop
    def magnetic_field_current_loop():
        """Magnetic field of a circular current loop"""
        
        # Parameters
        I = 1.0      # Current (A)
        R = 1.0      # Loop radius (m)
        mu_0 = 4*np.pi*1e-7  # Permeability of free space
        
        # Calculate field along axis
        z = np.linspace(-3, 3, 100)
        Bz = mu_0 * I * R**2 / (2 * (R**2 + z**2)**(3/2))
        
        plt.figure(figsize=(10, 6))
        
        plt.subplot(1, 2, 1)
        plt.plot(z, Bz*1e6, 'b-', linewidth=2)
        plt.xlabel('Distance along axis (m)')
        plt.ylabel('Magnetic Field (μT)')
        plt.title(f'Magnetic Field of Current Loop (I={I}A, R={R}m)')
        plt.grid(True, alpha=0.3)
        
        # Field lines visualization (simplified)
        plt.subplot(1, 2, 2)
        theta = np.linspace(0, 2*np.pi, 100)
        loop_x = R * np.cos(theta)
        loop_y = R * np.sin(theta)
        
        # Draw current loop
        plt.plot(loop_x, loop_y, 'r-', linewidth=3, label='Current Loop')
        
        # Simplified field line representation
        r_field = np.linspace(0.2, 3, 10)
        for r in r_field:
            # Approximate field lines
            phi = np.linspace(0, 2*np.pi, 50)
            field_x = r * np.cos(phi)
            field_y = 0.5 * r * np.sin(phi)
            plt.plot(field_x, field_y, 'b-', alpha=0.5, linewidth=1)
            plt.plot(field_x, -field_y, 'b-', alpha=0.5, linewidth=1)
        
        plt.xlabel('x (m)')
        plt.ylabel('y (m)')
        plt.title('Magnetic Field Lines')
        plt.axis('equal')
        plt.legend()
        
        plt.tight_layout()
        plt.show()
        
        return z, Bz
    
    # Execute electromagnetic field calculations
    electric_results = electric_field_point_charges()
    magnetic_results = magnetic_field_current_loop()
    
    return electric_results, magnetic_results

# Execute electromagnetic field analysis
em_results = electromagnetic_fields()

Thermodynamics and Statistical Mechanics

Explore thermal phenomena and statistical behavior:

# Thermodynamics and kinetic theory
def thermal_physics():
    """
    Explore thermodynamics and statistical mechanics
    """
    
    # Ideal gas law and kinetic theory
    def kinetic_theory_simulation():
        """Simulate kinetic theory of gases"""
        
        # Parameters
        N = 1000         # Number of particles
        T = 300          # Temperature (K)
        m = 4.65e-26     # Mass of N2 molecule (kg)
        
        # Maxwell-Boltzmann distribution
        def maxwell_boltzmann(v, T, m):
            """Maxwell-Boltzmann speed distribution"""
            k_B = 1.38e-23
            factor = 4 * np.pi * (m / (2 * np.pi * k_B * T))**(3/2)
            return factor * v**2 * np.exp(-m * v**2 / (2 * k_B * T))
        
        # Generate random velocities according to Maxwell-Boltzmann
        # (Simplified: using normal distribution for each component)
        sigma = np.sqrt(k_B * T / m)  # Standard deviation for each component
        
        vx = np.random.normal(0, sigma, N)
        vy = np.random.normal(0, sigma, N)
        vz = np.random.normal(0, sigma, N)
        
        # Calculate speeds
        speeds = np.sqrt(vx**2 + vy**2 + vz**2)
        
        # Plot speed distribution
        plt.figure(figsize=(12, 8))
        
        plt.subplot(2, 2, 1)
        plt.hist(speeds, bins=50, density=True, alpha=0.7, label='Simulation')
        
        # Theoretical Maxwell-Boltzmann distribution
        v_theory = np.linspace(0, np.max(speeds), 200)
        mb_theory = maxwell_boltzmann(v_theory, T, m)
        plt.plot(v_theory, mb_theory, 'r-', linewidth=2, label='Theory')
        
        plt.xlabel('Speed (m/s)')
        plt.ylabel('Probability Density')
        plt.title(f'Maxwell-Boltzmann Distribution (T={T}K)')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        # Calculate characteristic speeds
        v_avg = np.mean(speeds)
        v_rms = np.sqrt(np.mean(speeds**2))
        v_mp = np.sqrt(2 * k_B * T / m)  # Most probable speed
        
        plt.axvline(v_avg, color='blue', linestyle='--', label=f'Average: {v_avg:.0f} m/s')
        plt.axvline(v_rms, color='green', linestyle='--', label=f'RMS: {v_rms:.0f} m/s')
        plt.axvline(v_mp, color='red', linestyle='--', label=f'Most probable: {v_mp:.0f} m/s')
        plt.legend()
        
        # Energy distribution
        plt.subplot(2, 2, 2)
        kinetic_energies = 0.5 * m * speeds**2
        plt.hist(kinetic_energies / k_B, bins=50, density=True, alpha=0.7)
        plt.xlabel('Kinetic Energy / k_B (K)')
        plt.ylabel('Probability Density')
        plt.title('Kinetic Energy Distribution')
        plt.grid(True, alpha=0.3)
        
        # Temperature dependence
        plt.subplot(2, 2, 3)
        temperatures = [200, 300, 400, 500]
        v_range = np.linspace(0, 1500, 200)
        
        for T_temp in temperatures:
            mb_dist = maxwell_boltzmann(v_range, T_temp, m)
            plt.plot(v_range, mb_dist, linewidth=2, label=f'T = {T_temp}K')
        
        plt.xlabel('Speed (m/s)')
        plt.ylabel('Probability Density')
        plt.title('Temperature Dependence')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        # Pressure calculation from kinetic theory
        plt.subplot(2, 2, 4)
        volumes = np.linspace(0.01, 0.1, 100)  # m³
        n_moles = 1.0  # mol
        R = 8.314  # J/(mol⋅K)
        
        # Ideal gas law: PV = nRT
        pressures_ideal = n_moles * R * T / volumes
        
        plt.plot(volumes*1000, pressures_ideal/1000, 'b-', linewidth=2, label='Ideal Gas Law')
        plt.xlabel('Volume (L)')
        plt.ylabel('Pressure (kPa)')
        plt.title(f'P-V Diagram (T={T}K)')
        plt.grid(True, alpha=0.3)
        plt.legend()
        
        plt.tight_layout()
        plt.show()
        
        print(f"Theoretical values at T = {T}K:")
        print(f"Average speed: {np.sqrt(8*k_B*T/(np.pi*m)):.0f} m/s")
        print(f"RMS speed: {np.sqrt(3*k_B*T/m):.0f} m/s")
        print(f"Most probable speed: {np.sqrt(2*k_B*T/m):.0f} m/s")
        
        return speeds, kinetic_energies
    
    # Heat transfer
    def heat_transfer_simulation():
        """Simulate heat conduction"""
        
        # One-dimensional heat equation: ∂T/∂t = α ∂²T/∂x²
        # where α is thermal diffusivity
        
        # Parameters
        L = 1.0          # Length (m)
        alpha = 1e-4     # Thermal diffusivity (m²/s)
        dx = 0.01        # Spatial step
        dt = 0.1         # Time step
        t_max = 3600     # Maximum time (s)
        
        # Grid
        x = np.arange(0, L + dx, dx)
        nx = len(x)
        
        # Check stability condition
        stability = alpha * dt / dx**2
        print(f"Stability parameter: {stability:.3f} (should be ≤ 0.5)")
        
        # Initial condition: hot at one end, cold at the other
        T = np.zeros(nx)
        T[0] = 100    # Hot end (°C)
        T[-1] = 0     # Cold end (°C)
        
        # Time stepping
        times = np.arange(0, t_max + dt, dt)
        T_history = []
        
        for t in times[::int(len(times)/10)]:  # Store every 10th time step
            T_history.append(T.copy())
            
            # Update temperature using finite difference
            T_new = T.copy()
            for i in range(1, nx-1):
                T_new[i] = T[i] + alpha * dt / dx**2 * (T[i+1] - 2*T[i] + T[i-1])
            
            T = T_new
        
        # Plot temperature evolution
        plt.figure(figsize=(10, 6))
        
        plt.subplot(1, 2, 1)
        for i, T_snapshot in enumerate(T_history):
            time_label = f't = {i * t_max / 10 / 60:.0f} min'
            plt.plot(x, T_snapshot, linewidth=2, label=time_label)
        
        plt.xlabel('Position (m)')
        plt.ylabel('Temperature (°C)')
        plt.title('Heat Conduction Over Time')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        # Steady-state solution (linear)
        plt.subplot(1, 2, 2)
        T_steady = 100 * (1 - x / L)  # Linear temperature profile
        plt.plot(x, T_history[-1], 'b-', linewidth=2, label='Numerical solution')
        plt.plot(x, T_steady, 'r--', linewidth=2, label='Analytical steady-state')
        plt.xlabel('Position (m)')
        plt.ylabel('Temperature (°C)')
        plt.title('Final Temperature Profile')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.show()
        
        return x, T_history
    
    # Execute thermal physics simulations
    speeds, energies = kinetic_theory_simulation()
    x_heat, T_heat = heat_transfer_simulation()
    
    return speeds, energies, x_heat, T_heat

# Execute thermal physics analysis
thermal_results = thermal_physics()

Building Physics Intuition

Dimensional Analysis and Scaling

Physics understanding begins with dimensional analysis:

# Dimensional analysis tools
def dimensional_analysis():
    """
    Explore dimensional analysis and scaling laws
    """
    
    # Fundamental dimensions
    dimensions = {
        'length': 'L',
        'mass': 'M', 
        'time': 'T',
        'electric_current': 'I',
        'temperature': 'Θ',
        'amount': 'N',
        'luminous_intensity': 'J'
    }
    
    # Common physical quantities and their dimensions
    quantities = {
        'velocity': 'L T⁻¹',
        'acceleration': 'L T⁻²',
        'force': 'M L T⁻²',
        'energy': 'M L² T⁻²',
        'power': 'M L² T⁻³',
        'pressure': 'M L⁻¹ T⁻²',
        'electric_field': 'M L T⁻³ I⁻¹',
        'magnetic_field': 'M T⁻² I⁻¹'
    }
    
    print("DIMENSIONAL ANALYSIS EXAMPLES")
    print("="*40)
    
    # Example 1: Pendulum period
    print("Example 1: Simple Pendulum Period")
    print("Variables: length L, gravity g, mass m")
    print("Dimensions: [L] = L, [g] = L T⁻², [m] = M")
    print("Proposed form: T = L^a × g^b × m^c")
    print("Dimension equation: T = L^a × (L T⁻²)^b × M^c")
    print("                   T = L^(a+b) × T^(-2b) × M^c")
    print("Matching dimensions:")
    print("  Time: 1 = -2b  →  b = -1/2")
    print("  Length: 0 = a + b  →  a = 1/2")
    print("  Mass: 0 = c  →  c = 0")
    print("Result: T ∝ √(L/g)")
    
    # Numerical verification
    L_values = np.array([0.5, 1.0, 1.5, 2.0])  # lengths in meters
    g = 9.81
    T_predicted = 2 * np.pi * np.sqrt(L_values / g)
    
    plt.figure(figsize=(10, 6))
    plt.subplot(1, 2, 1)
    plt.plot(L_values, T_predicted, 'bo-', linewidth=2, markersize=8)
    plt.xlabel('Length (m)')
    plt.ylabel('Period (s)')
    plt.title('Pendulum Period vs Length')
    plt.grid(True, alpha=0.3)
    
    # Example 2: Drag force scaling
    print("\nExample 2: Drag Force at High Speed")
    print("Variables: velocity v, density ρ, area A, coefficient C_d")
    print("Expected form: F_drag = ½ × C_d × ρ × A × v²")
    
    # Show velocity scaling
    velocities = np.linspace(10, 100, 20)
    rho = 1.225  # Air density (kg/m³)
    A = 2.0      # Cross-sectional area (m²)
    C_d = 0.3    # Drag coefficient
    
    F_drag = 0.5 * C_d * rho * A * velocities**2
    
    plt.subplot(1, 2, 2)
    plt.plot(velocities, F_drag, 'r-', linewidth=2)
    plt.xlabel('Velocity (m/s)')
    plt.ylabel('Drag Force (N)')
    plt.title('Drag Force vs Velocity (∝ v²)')
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    return quantities, T_predicted, F_drag

# Execute dimensional analysis
dim_analysis = dimensional_analysis()

Error Analysis and Uncertainty

Understanding measurement uncertainty is crucial in physics:

# Error analysis and uncertainty propagation
def error_analysis():
    """
    Demonstrate error analysis and uncertainty propagation
    """
    
    print("ERROR ANALYSIS IN PHYSICS")
    print("="*30)
    
    # Example: Measuring gravitational acceleration
    # Using pendulum: g = 4π²L/T²
    
    # Measurements with uncertainties
    L = 1.000          # Length (m)
    dL = 0.001         # Uncertainty in length (m)
    T = 2.006          # Period (s)
    dT = 0.010         # Uncertainty in period (s)
    
    # Calculate g
    g = 4 * np.pi**2 * L / T**2
    
    # Uncertainty propagation: g = 4π²L/T²
    # Relative uncertainty: δg/g = δL/L + 2δT/T
    relative_uncertainty = dL/L + 2*dT/T
    dg = g * relative_uncertainty
    
    print(f"Measurement results:")
    print(f"Length: L = {L:.3f} ± {dL:.3f} m")
    print(f"Period: T = {T:.3f} ± {dT:.3f} s")
    print(f"Calculated g = {g:.2f} ± {dg:.2f} m/s²")
    print(f"Accepted value: 9.81 m/s²")
    print(f"Percent error: {abs(g - 9.81)/9.81 * 100:.1f}%")
    
    # Monte Carlo error propagation
    def monte_carlo_errors(n_samples=10000):
        """Use Monte Carlo method for error propagation"""
        
        # Generate random samples
        L_samples = np.random.normal(L, dL, n_samples)
        T_samples = np.random.normal(T, dT, n_samples)
        
        # Calculate g for each sample
        g_samples = 4 * np.pi**2 * L_samples / T_samples**2
        
        # Statistics
        g_mean = np.mean(g_samples)
        g_std = np.std(g_samples)
        
        print(f"\nMonte Carlo results ({n_samples} samples):")
        print(f"g = {g_mean:.2f} ± {g_std:.2f} m/s²")
        
        # Plot distribution
        plt.figure(figsize=(10, 6))
        
        plt.subplot(1, 2, 1)
        plt.hist(g_samples, bins=50, density=True, alpha=0.7, edgecolor='black')
        plt.axvline(g_mean, color='red', linestyle='--', linewidth=2, label=f'Mean: {g_mean:.2f}')
        plt.axvline(9.81, color='green', linestyle='--', linewidth=2, label='True value: 9.81')
        plt.xlabel('g (m/s²)')
        plt.ylabel('Probability Density')
        plt.title('Distribution of g Values')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        # Error vs number of measurements
        plt.subplot(1, 2, 2)
        n_measurements = np.logspace(1, 4, 20).astype(int)
        standard_errors = []
        
        for n in n_measurements:
            # Standard error decreases as 1/√n
            standard_error = g_std / np.sqrt(n)
            standard_errors.append(standard_error)
        
        plt.loglog(n_measurements, standard_errors, 'bo-', linewidth=2)
        plt.loglog(n_measurements, 1/np.sqrt(n_measurements), 'r--', 
                  linewidth=2, label='∝ 1/√n')
        plt.xlabel('Number of Measurements')
        plt.ylabel('Standard Error (m/s²)')
        plt.title('Error Reduction with More Measurements')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.show()
        
        return g_samples, g_mean, g_std
    
    # Execute Monte Carlo analysis
    g_samples, g_mean, g_std = monte_carlo_errors()
    
    return g, dg, g_samples

# Execute error analysis
error_results = error_analysis()

Next Steps in Your Physics Journey

Immediate Explorations

1. Planetary Motion: Simulate orbital mechanics and Kepler's laws
2. Wave Interference: Explore wave superposition and interference patterns
3. Quantum Basics: Introduction to wave-particle duality
4. Thermal Equilibrium: Statistical mechanics fundamentals

Building Toward Advanced Physics

• Classical Field Theory: Maxwell's equations and electromagnetic waves
• Quantum Mechanics: Schrödinger equation and quantum systems
• Statistical Physics: Phase transitions and critical phenomena
• Relativity: Special and general relativistic effects

Research Skills Development

• Experimental Design: Planning and analyzing physics experiments
• Data Analysis: Statistical methods for physics data
• Modeling: Creating and validating physical models
• Communication: Presenting physics results effectively

Computational physics in CoCalc opens new ways to understand the physical world. Start with fundamental concepts, build your computational skills, and gradually explore more sophisticated phenomena. The combination of theory, computation, and visualization makes complex physics accessible and engaging.

Begin your computational physics journey. Access physics simulations and start exploring at cocalc.com

We are thrilled to announce a special opportunity to meet William Stein, the CEO and Founder of CoCalc, at the JMM meeting in Seattle, WA.

Don't miss this chance to engage with William as he presents a live demo of CoCalc! With numerous publications under his belt, William previously served as a tenured professor at the University of Washington until 2019, at which point he committed full-time to growing the CoCalc Platform.

William has made significant contributions to the field of Computational Algebraic Number Theory and is the creator of the Computer Algebra System Sage.

Come find us at booth 507 in the Exhibit Hall during the Grand Opening Reception.

Welcome to Mathematical Discovery

Pure mathematics—the exploration of mathematical concepts for their own beauty and elegance—has never been more accessible. CoCalc provides a comprehensive environment where you can explore algebra, number theory, geometry, and analysis without the barriers of complex software installation or expensive licenses.

For detailed information about SageMath and mathematical computing features, see the CoCalc SageMath documentation.

Whether you're a student encountering abstract mathematics for the first time, a researcher exploring new mathematical territories, or simply someone fascinated by the beauty of mathematical truth, CoCalc offers the tools you need to transform abstract concepts into concrete understanding.

Your Mathematical Toolkit

SageMath: Your Mathematical Companion

SageMath is your primary tool for mathematical exploration—a comprehensive system that combines the power of dozens of specialized mathematical packages into one unified interface.

Note: Use a SageMath kernel/worksheet for these examples, not Python.

# Welcome to mathematical computing!
# Let's start with basic symbolic mathematics

# Working with symbolic variables
x, y, z = var('x y z')

# Symbolic expressions and algebra
expr = (x + 1)^3
expanded = expand(expr)
factored = factor(x^3 + 3*x^2 + 3*x + 1)

print("Original expression:", expr)
print("Expanded form:", expanded)
print("Factored form:", factored)

# Basic calculus
f = x^2 + 3*x + 2
derivative = diff(f, x)
integral = integrate(f, x)

print("\nFunction: f(x) =", f)
print("Derivative: f'(x) =", derivative)
print("Integral: ∫f(x)dx =", integral)

Output:

Original expression: (x + 1)^3
Expanded form: x^3 + 3*x^2 + 3*x + 1
Factored form: (x + 1)^3
Function: f(x) = x^2 + 3*x + 2
Derivative: f'(x) = 2*x + 3
Integral: ∫f(x)dx = 1/3*x^3 + 3/2*x^2 + 2*x

Exploring Number Theory

Number theory—the study of integers and their properties—comes alive with computational exploration:

# Number theory explorations
print("=== NUMBER THEORY ADVENTURES ===")

# Prime numbers and factorization
n = 2023
print("\nIs", n, "prime?", is_prime(n))
print("Prime factorization of", n, ":", factor(n))

# Finding primes
primes_up_to_100 = [p for p in range(2, 101) if is_prime(p)]
print("\nFirst few primes:", primes_up_to_100[:10])
print("Number of primes up to 100:", len(primes_up_to_100))

# The Euclidean algorithm
a, b = 48, 18
gcd_result = gcd(a, b)
print("\ngcd(", a, ",", b, ") =", gcd_result)

# Extended Euclidean algorithm
g, u, v = xgcd(a, b)
print("Extended:", u, "·", a, " + ", v, "·", b, " = ", g)

Output:

=== NUMBER THEORY ADVENTURES ===

Is 2023 prime? False
Prime factorization of 2023 : 7 * 17^2

First few primes: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
Number of primes up to 100: 25

gcd( 48 , 18 ) = 6
Extended: -1 · 48  +  3 · 18  =  6

Algebraic Structures

Explore the fundamental structures that underlie mathematics:

# Group theory basics
print("=== ALGEBRAIC STRUCTURES ===")

# Modular arithmetic
print("\nModular arithmetic:")
for i in range(12):
    print(i, "mod 5 =", i % 5)

# Working with permutations
# Create a simple permutation group
S3 = SymmetricGroup(3)
print("\nSymmetric group S3 has order:", S3.order())
print("Elements of S3:", list(S3))

# Group operations
g1 = S3([2, 1, 3])  # Swap first two elements
g2 = S3([1, 3, 2])  # Swap last two elements
product = g1 * g2
print("\nPermutation multiplication:")
print(g1, "*", g2, "=", product)

Output:

=== ALGEBRAIC STRUCTURES ===

Modular arithmetic:
0 mod 5 = 0
1 mod 5 = 1
2 mod 5 = 2
3 mod 5 = 3
4 mod 5 = 4
5 mod 5 = 0
6 mod 5 = 1
7 mod 5 = 2
8 mod 5 = 3
9 mod 5 = 4
10 mod 5 = 0
11 mod 5 = 1

Symmetric group S3 has order: 6
Elements of S3: [(), (2,3), (1,2), (1,2,3), (1,3,2), (1,3)]

Permutation multiplication:
(1,2) * (2,3) = (1,2,3)

Calculus and Analysis

Move from discrete to continuous mathematics:

# Calculus explorations
print("=== CALCULUS AND ANALYSIS ===")

# Limits
x = var('x')
limit_expr = sin(x)/x
limit_result = limit(limit_expr, x=0)
print("lim(x→0) sin(x)/x =", limit_result)

# Series expansions
f = e^x
taylor_series = f.taylor(x, 0, 5)  # Taylor series around x=0, degree 5
print("\nTaylor series of e^x:", taylor_series)

# Definite integrals
integral_result = integrate(x^2 * e^(-x^2), x, -oo, oo)
print("\n∫_{-∞}^{∞} x²e^(-x²) dx =", integral_result)

# Plotting functions
p1 = plot(sin(x), (x, -2*pi, 2*pi), color='blue', legend_label='sin(x)')
p2 = plot(cos(x), (x, -2*pi, 2*pi), color='red', legend_label='cos(x)')
combined_plot = p1 + p2
combined_plot.show()

Output:

=== CALCULUS AND ANALYSIS ===
lim(x→0) sin(x)/x = 1

Taylor series of e^x: 1/120*x^5 + 1/24*x^4 + 1/6*x^3 + 1/2*x^2 + x + 1

∫_{-∞}^{∞} x²e^(-x²) dx = 1/2*sqrt(pi)

Linear Algebra: The Language of Modern Mathematics

Linear algebra provides the foundation for understanding higher mathematics:

# Linear algebra basics
print("=== LINEAR ALGEBRA ===")

# Matrices and vectors
A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
v = vector([1, 2, 3])

print("Matrix A:")
print(A)
print("Vector v:", v)

# Matrix operations
det_A = A.determinant()
print("\nDeterminant of A:", det_A)

# Eigenvalues and eigenvectors
B = Matrix([[2, 1], [1, 2]])
eigenvals = B.eigenvalues()
eigenvects = B.eigenvectors_right()

print("\nMatrix B:")
print(B)
print("Eigenvalues:", eigenvals)
print("Eigenvectors:")
for eval, evect, mult in eigenvects:
    print("  λ =", eval, ", v =", evect[0], ", multiplicity =", mult)

Output:

=== LINEAR ALGEBRA ===
Matrix A:
[1 2 3]
[4 5 6]
[7 8 9]
Vector v: (1, 2, 3)

Determinant of A: 0

Matrix B:
[2 1]
[1 2]
Eigenvalues: [3, 1]
Eigenvectors:
  λ = 3 , v = (1, 1) , multiplicity = 1
  λ = 1 , v = (1, -1) , multiplicity = 1

Mathematical Visualization

Mathematics becomes more intuitive when you can see it:

# 2D plotting
x = var('x')
p1 = plot(sin(x), (x, -2*pi, 2*pi), color='blue', legend_label='sin(x)')
p2 = plot(cos(x), (x, -2*pi, 2*pi), color='red', legend_label='cos(x)')

combined_plot = p1 + p2
combined_plot.axes_labels(['x', 'y'])
combined_plot.legend(True)
combined_plot.show(title='Trigonometric Functions')

# 3D surface
x, y = var('x y')
surface_plot = plot3d(x^2 + y^2, (x, -2, 2), (y, -2, 2))
surface_plot.show()

Getting Started: Your First Mathematical Explorations

Exercise 1: Number Theory Investigation

# Investigate perfect numbers
def is_perfect(n):
    """Check if n is a perfect number"""
    divisors = [i for i in range(1, n) if n % i == 0]
    return sum(divisors) == n

# Find perfect numbers up to 100
perfect_numbers = [n for n in range(1, 101) if is_perfect(n)]
print("Perfect numbers up to 100:", perfect_numbers)

# Investigate their properties
for p in perfect_numbers:
    divisors = [i for i in range(1, p) if p % i == 0]
    print(p, ": divisors =", divisors, ", sum =", sum(divisors))

Output:

Perfect numbers up to 100: [6, 28]
6 : divisors = [1, 2, 3] , sum = 6
28 : divisors = [1, 2, 4, 7, 14] , sum = 28

Exercise 2: Polynomial Exploration

# Explore polynomial behavior
x = var('x')
polynomials = [
    x^2 - 1,           # Quadratic
    x^3 - 3*x + 1,     # Cubic
    x^4 - 5*x^2 + 6    # Quartic
]

for poly in polynomials:
    print("\nPolynomial:", poly)
    
    # Find roots
    roots = solve(poly == 0, x)
    print("Roots:", roots)
    
    # Factor if possible
    try:
        factored = factor(poly)
        print("Factored form:", factored)
    except:
        print("Cannot factor over rationals")
    
    # Plot the polynomial
    plot(poly, (x, -3, 3)).show()

Output:

Polynomial: x^2 - 1
Roots: [x == -1, x == 1]
Factored form: (x - 1)*(x + 1)

Polynomial: x^3 - 3*x + 1
Roots: [x == -1/2*sqrt(5) - 1/2, x == 1/2*sqrt(5) - 1/2, x == 1]
Factored form: x^3 - 3*x + 1

Polynomial: x^4 - 5*x^2 + 6
Roots: [x == -sqrt(3), x == sqrt(3), x == -sqrt(2), x == sqrt(2)]
Factored form: (x^2 - 3)*(x^2 - 2)

Exercise 3: Matrix Magic

# Explore special matrices
print("=== SPECIAL MATRICES ===")

# Identity matrix
I = identity_matrix(3)
print("Identity matrix:")
print(I)

# Rotation matrix (2D)
angle = pi/4  # 45 degrees
rotation_2d = Matrix([[cos(angle), -sin(angle)], 
                      [sin(angle), cos(angle)]])
print("\n45° rotation matrix:")
print(rotation_2d)

# Apply rotation to a vector
v = vector([1, 0])
rotated_v = rotation_2d * v
print("Original vector:", v)
print("Rotated vector:", rotated_v)

# Verify the rotation preserves length
print("Original length:", v.norm())
print("Rotated length:", rotated_v.norm())

Output:

=== SPECIAL MATRICES ===
Identity matrix:
[1 0 0]
[0 1 0]
[0 0 1]

45° rotation matrix:
[1/2*sqrt(2) -1/2*sqrt(2)]
[1/2*sqrt(2)  1/2*sqrt(2)]

Original vector: (1, 0)
Rotated vector: (1/2*sqrt(2), 1/2*sqrt(2))
Original length: 1
Rotated length: 1

Building Mathematical Intuition

Understanding Through Computation

Mathematical intuition develops through active exploration. Use CoCalc to:

1. Test Conjectures: Try examples and look for patterns
2. Visualize Concepts: Plot functions and geometric objects
3. Verify Calculations: Check hand computations with symbolic math
4. Explore Edge Cases: See what happens at boundaries and special values

Example: The Fibonacci Sequence

# Fibonacci explorations
def fibonacci_sequence(n):
    """Generate first n Fibonacci numbers"""
    fib = [1, 1]
    for i in range(2, n):
        fib.append(fib[i-1] + fib[i-2])
    return fib

# Generate Fibonacci numbers
fib_nums = fibonacci_sequence(20)
print("First 20 Fibonacci numbers:", fib_nums)

# Investigate the golden ratio connection
golden_ratio = (1 + sqrt(5))/2
ratios = [fib_nums[i+1]/fib_nums[i] for i in range(len(fib_nums)-1)]

print("\nGolden ratio:", float(golden_ratio))
print("Consecutive Fibonacci ratios:")
for i, ratio in enumerate(ratios[-10:], len(ratios)-9):
    print("F(", i+1, ")/F(", i, ") =", float(ratio))

# Plot convergence to golden ratio
data_points = [(i, float(ratios[i-1])) for i in range(1, len(ratios)+1)]
ratio_plot = list_plot(data_points, color='blue', plotjoined=True, legend_label='F(n+1)/F(n)')
ratio_plot += line([(1, float(golden_ratio)), (len(ratios), float(golden_ratio))], color='red', linestyle='--', legend_label='Golden Ratio')
ratio_plot.axes_labels(['n', 'Ratio'])
ratio_plot.title('Fibonacci Ratios Converging to Golden Ratio')
ratio_plot.show()

Next Steps in Your Mathematical Journey

Immediate Explorations

1. Prime Number Patterns: Investigate prime gaps and distributions
2. Geometric Sequences: Explore convergence and divergence
3. Function Transformations: See how parameters affect graphs
4. Matrix Powers: Discover patterns in repeated matrix multiplication

Preparing for Advanced Topics

• Abstract Algebra: Group and ring theory
• Real Analysis: Rigorous foundations of calculus
• Complex Analysis: Functions of complex variables
• Topology: Properties preserved under continuous deformations

Mathematical Research Skills

• Conjecture Formation: Making educated mathematical guesses
• Proof Techniques: Direct, indirect, and inductive reasoning
• Mathematical Writing: Communicating ideas clearly
• Collaboration: Working with others on mathematical problems

Resources for Continued Learning

Documentation and Help

• SageMath Documentation: Comprehensive guides and examples
• CoCalc Help: Platform-specific tutorials and tips
• Mathematical Communities: Online forums and discussion groups

Practice Problems

• Project Euler: Computational mathematics challenges
• Mathematical Olympiad Problems: Contest mathematics
• Research Papers: Current mathematical investigations

Pure mathematics in CoCalc opens doors to a universe of mathematical beauty and discovery. Start with simple explorations, build your computational skills, and gradually tackle more sophisticated problems. Every mathematician started with curiosity—let CoCalc help you transform that curiosity into deep mathematical understanding.

Begin your mathematical journey today. Access SageMath and start exploring at cocalc.com

Join Us at JMM for an Exclusive Meet & Greet and Live Demo with William Stein!

We are thrilled to announce a special opportunity to meet William Stein, the CEO and Founder of CoCalc, at the JMM meeting in Seattle, WA.

Don't miss this chance to engage with William as he presents a live demo of CoCalc! With numerous publications under his belt, William previously served as a tenured professor at the University of Washington until 2019, at which point he committed full-time to growing the CoCalc Platform.

William has made significant contributions to the field of Computational Algebraic Number Theory and is the creator of the Computer Algebra System Sage.

Come find us at booth 507 in the Exhibit Hall during the Grand Opening Reception.

SageMath, Inc. is pleased to announce successfully passing the SOC 2 Type II audit!

Service Organization Controls 2 (SOC 2) is a framework that is governed by the American Institute of Certified Public Accountants (AICPA). With a SOC 2 audit, an independent service auditor reviewed our policies, procedures, and evidence to determine if the controls are designed and operating effectively. A SOC 2 report communicates our commitment to data security and protection of our customers information.

Request access to the report and view the current status of controls at https://trust.cocalc.com/

We wanted to send out this quick message to let everyone know that CoCalc will be hosting booth (#208) at INFORMS 2024 in Seattle, WA!

We will live demo our platform in the exhibit hall all week and present a Technology Showcase on Tuesday, Oct. 22nd, at 2:15 p.m. PT.

As a short aside, you might also be interested to know that accessing on-demand H100 GPUs starts at $1.98 per hour via our compute server functionality. (It is all metered per second.) Other more budget-friendly options are available as well.

Our goal is to make your experience with CoCalc as smooth and efficient as possible. To ensure you stay up-to-date with the latest tips and tricks, we highly encourage you to subscribe! That way, you'll never miss a new tutorial and can always access the latest content right as it's released.

Please let us know what you want to see next! For more in-depth information, don't forget to visit our detailed Documentation.

Also, if you have any questions or want to chat with us directly, don't hesitate to book a video chat with our team.

Under the hood, this is accomplished by an improved /api/v2/exec endpoint. The parameter async_call returns an ID, which you can use to monitor and control the underlying process. See /api/v2/exec for more details.

• Release Tour Sage 10.4
• Examples from the tour

Older versions of Sage remain available. For Sage Worksheets and on the terminal, you can configure the version of sage in your project by running sage_select ... in a Terminal. Regarding Jupyter, you can switch to the newer kernel any time!

```mermaid
block-beta
columns 1
  db(("DB"))
  blockArrowId6<["&nbsp;&nbsp;&nbsp;"]>(down)
  block:ID
    A
    B["A wide one in the middle"]
    C
  end
  space
  D
  ID --> D
  C --> D
  style B fill:#969,stroke:#333,stroke-width:4px
```

and it will get rendered like this:

block-beta
columns 1
  db(("DB"))
  blockArrowId6<["&nbsp;&nbsp;&nbsp;"]>(down)
  block:ID
    A
    B["A wide one in the middle"]
    C
  end
  space
  D
  ID --> D
  C --> D
  style B fill:#969,stroke:#333,stroke-width:4px

Using Mermaid in exactly this way is also fully supported in JupyterLab and on GitHub. Moreover, if you publish documents on the CoCalc share server, Mermaid also gets rendered properly, e.g., see these examples:

• https://cocalc.com/wstein/dev/mermaid

Widgets in CoCalc work almost the same as the latest official upstream version. The main difference is that widgets support realtime collaboration and the full state of widgets is stored on the backend server. This means that if multiple people use a notebook at once (or you open the same notebook in multiple browsers), then state of widgets are sync'd. Also you don't have to re-evaluate code for widgets to appear if you refresh your browser.

• An open source library that came out of this project: https://github.com/sagemathinc/cocalc-widgets
• Upstream IPyWidgets, now all examples are supported: https://ipywidgets.readthedocs.io/en/stable/
• CoCalc Widget docs: https://doc.cocalc.com/jupyter-enhancements.html#widgets-in-cocalc

Basically, you can type a string in that search box, hit return, and see the last 100 files (over the last year) that you edited whose name has that as a substring. You can use any PostgreSQL ilike patterns, e.g., % for wildcard. It's just a tiny thing that was easy to implement, but could really help sometimes when you're not sure where a file is.

If you want to try the encrypted wireguard vpn, just start two compute servers in the same project. Then type more /etc/hosts and see that compute-server-[n] resolves to the vpn address of the compute server (which will be of the form 10.11.x.y). Do apt-get install -y iputils-ping and then you can ping from one to another, e.g., ping compute-server-[n] . Also, if you set a subdomain so https://foo.cocalc.cloud works, then you can also use foo as a name to connect to. The exciting thing is that:

• all ports are opened on the vpn
• all traffic is fully encrypted
• only compute servers in the same project have access to the vpn
• this fully works across clouds, i.e., some nodes on google cloud and some on hyperstack, and they all connect to each other in a unified way.

Note that on-prem has one limitation still, e.g., on prem nodes can connect to all cloud nodes and all cloud nodes can connect to on prem nodes, but on prem nodes can't connect to each other. To make this work in general is complicated and expensive, requiring TURN servers, so we're not doing that for now. There's some special cases that will be supported in the future. This isn't the highest priority, since probably nobody but me uses on prem with more than one server so far...

Anyway, I think now that this is in place, implementing our new high performance distributed filesystem will be possible! Stay tuned.

Here is an example how I improved a plot of a t-test using R in a Jupyter Notebook. This is a visual check to see, if the data is really significantly different. The plot looks a bit boring, though:

Via AI Tools → Improve, I can tell GPT-4 Omni to make this a violin plot and more colorful

I get a response and can review the changes in side-chat. The result looks like that:

Much better!

Ok, but wait, what's the T-Test? Here, I'm asking Gemini Flash to explain this to me, and there was also something called shapiro. To learn more, I opened a new chat and asked away. I told Gemini to also show me how to do this in R – which I can run directly in the chat.

Feel free to browse this curated playlist which houses these enlightening videos. Dive in and discover how to harness the full potential of CoCalc like never before! The power of CoCalc is at your fingertips - explore, learn, and elevate your experience! Browse the playlist.

Note: if you had installed R packages locally in your project before, you have to re-compile them.

The default "R Statistics" compute server image also includes R 4.4 by default as well.

As usual, there are also a ton of upgrades for the Python 3 (system-wide) environment, and various underlying Linux packages.

If you run into problems, please let us know in support. You can also always switch back to the previous environment in Project Settings → Control → Software Environment and select "Ubuntu 22.04 // Previous".

We were in Vienna for ICLR in May 2024, and as always, the scale of the research was incredible. You couldn't walk a single poster aisle without seeing massive transformers, complex generative models, or new self-supervised learning techniques that required immense computational power.

But it was the conversations in the hallways between talks that were most interesting. Beyond the model architectures, the one question that came up constantly was a practical one: "How did you get enough GPU time for that?"

It was clear that access to compute is a huge bottleneck. We talked to many researchers who were tired of maintaining their own hardware and just wanted to spin up a powerful GPU via the cloud for a big training run without a lot of hassle. Moments later, we’d talk to another team that had invested heavily in their own local cluster and wanted to use their own machines for their work.

It was a great reminder that there's no single "right" way to do research. The real need is for flexibility—the ability to use local machines for development and then scale up to the cloud when it's time to really push a model.

As a team that thinks about research infrastructure, it was fascinating to see the community navigating this hybrid future. It’s a complex but really interesting challenge, and it was great to see it being discussed so openly.

A huge thank you to the ICLR organizers for another fantastic conference.

— The CoCalc Team

We just wrapped up our time at MLSys in Santa Clara, an event that’s special because it focuses on the "how" of machine learning. While other conferences often center on model architectures and theoretical breakthroughs, MLSys dives deep into the systems and engineering that make those breakthroughs possible.

The conference is dedicated to the full, end-to-end workflow of ML. The conversations were about the crucial, complex engineering that underpins every great result: building efficient data pipelines, managing training infrastructure at scale, and solving the challenges of deploying and serving models robustly.

It was great to see a whole community focused on these operational hurdles. So much of a researcher's time is spent moving between different tools for data prep, training, and analysis. For our team, it was inspiring to see so many smart people working to streamline that entire journey from raw data to finished paper. It’s clear that closing the gaps between these different stages is a huge priority for the field.

Thanks to the MLSys organizers for creating a space for these crucial conversations, and to everyone we spoke with at the event.

— The CoCalc Team

cocalc.com

We recently spent time at AISTATS, and what makes that conference so unique is that it’s where two distinct worlds collide: the rigor of classical statistics and the scale of modern AI.

One talk might be a deep dive into causal inference or Bayesian methods, and the very next could be about the statistical interpretability of a massive deep learning model. The whole event is focused on answering fundamental questions about AI through a statistical lens, tackling big issues like uncertainty quantification and building more transparent models.

In the hallways, this led to a lot of conversations about a common workflow challenge. Many researchers we spoke with feel like they're working with two separate toolboxes. They might do their heavy statistical lifting in R or with Python’s statsmodels, but then have to apply those insights to a neural network built in PyTorch or TensorFlow.

It’s a subtle but constant friction—moving data, translating code, and trying to get these two distinct environments to talk to each other seamlessly. As a team that thinks a lot about integrated scientific workflows, it was fascinating to see. It’s a classic problem: how do you make two toolboxes feel like one?

A huge thank you to the AISTATS organizers for creating a space where these two critical fields can meet and push each other forward.

— The CoCalc Team

cocalc.com

We had a fantastic time connecting with folks at AISTATS (the International Conference on Artificial Intelligence and Statistics). This is a cornerstone event for anyone working on the statistical foundations of AI, and it was great to meet so many of you in person.

We Want to Support Your Community

For researchers in AI and statistics, CoCalc is your collaborative, cloud-based workspace. We bridge the gap between powerful tools and seamless teamwork.

• All Your Tools in One Place: Access R, SciPy, TensorFlow, and PyTorch in a single, browser-based environment. No more setup headaches.
• Collaborate in Real-Time: Work together on code, data analysis, and model building with shared projects and simultaneous editing.
• Powerful Computing: From complex Bayesian models to large-scale AI, get the computational resources you need.
• Reproducible Research: Easily track your work, manage data, and document your entire process for transparent and reliable results.

Inspiration at AISTATS in Valencia, Spain.

The conversations we had at AISTATS were certainly insightful. Understanding the computational challenges you face in areas like causal inference, model interpretability, and probabilistic methods helps us make CoCalc even better for the AI and statistics community.

Thanks for all of the engagement at our booth!

Once you select Hyperstack after starting to create a compute server, click the A100 tag and you'll see this:

Note that for $3.60/hour you get an 80GB A100, and these are all standard instances. You can also see that at least right now many are available. Everything else works very similar to Google cloud, except that:

• startup time is slower -- definitely expect about 5-10 minutes from when you click "Start" until you can use the compute server. However, it's very likely to work, unlike Google cloud GPU's (especially spot instances). Google cloud is extremely good for CPU, but for GPU it's not as good.
• Many of the server configurations have over 500GB of very fast local ephemeral disk, in case you need that for scratch. It's ephemeral, so goes away when you stop the server.
• The local disk on the server should be as fast or faster than Google cloud, but cheaper.
• All network usage is free, whereas egress from Google cloud is quite expensive.
• There's a different range of GPU's. Sometimes there are a lot of H100's but in the middle of the day on Wednesday, there aren't. Yesterday there were dozens of them.
• By default only a Python (Anaconda) image and an Ollama image are visible, since they are small. When you select the Python image, you'll likely have to type conda install ... in a terminal to install some packages you need. If you click the "Advanced" checkbox when selecting an image, you can select from the full range of images. However, the first startup time for your server maybe be MUCH slower for big images (e.g., think "20-30 minutes" for the huge Colab image). Starting the server a second time is fast again.

• Live disk enlarging does work, but with a limit of at most 25 times due to Hyperstack architecture.

LINK: https://github.com/sagemathinc/cocalc-howto/blob/main/onprem.md

We add an on-prem compute server running on my Macbook Pro laptop to a CoCalc (https://cocalc.com) project, and using the compute server via a Jupyter notebook and a terminal. This involves creating an Ubuntu 22.04 virtual machine via multipass, and pasting a line of code into the VM to connect it to CoCalc.

After using a compute server running on my laptop, I create another compute server running on Lambda cloud (https://lambdalabs.com/). This involves renting a powerful server with an H100 GPU, waiting a few minutes for it to boot up, then pasting in a line of code. The compute server gets configured, starts up, and we are able to confirm that the H100 is available. We then type "conda install -y pytorch" to install pytorch, and use Claude3 to run a demo involving the GPU and train a toy model.

VIDEO: https://youtu.be/c7XHYBDTplw

Open a project on https://cocalc.com, then with one click in the file explorer, launch VS Code running on the project. You can them install and use a Jupyter notebook inside VS Code, and edit Python code and using a terminal.

When you need more power, add a compute server to your project. For example, in the video we demo adding a compute server that has 128GB of RAM and the latest Google cloud n4 machine type. It's a spot instance, which is great for a quick demo. It's good to configure DNS and autorestart, and launch our compute server, watching it boot via the serial console. Once the server is running, launch VS Code with one click, use a Jupyter notebook, edit Python code, and open a terminal and confirm that the underlying machine has 128GB of RAM.

You can also make a CoCalc terminal that runs on the compute server by clicking "+New --> Linux Terminal", then clicking the Server button and selecting your compute server.

This costs just a few cents, as you can confirm using the "Upgrades" tab (and scrolling down). When you're done, deprovision the server, unless you need to keep data that is only on the server.

Checkout out https://github.com/sagemathinc/cocalc-howto/blob/main/jupyterlab.md or the video at https://youtu.be/LLtLFtD8qfo

Due to major recent work by Harald Schilly, https://CoCalc.com also has very similar functionality! Also, in CoCalc, you pay as you go for exactly the tokens you use with each model, and it typically costs our users far less than $20/month, with many of the models being free. Instead of paying $20/month, add $10 in credit to your CoCalc account (which never expires) and pay for exactly what you actually use.

Then ask a question, and follow up by using DIFFERENT MODELS and regenerate the response with any model.

You can see all responses in the history:

The superpower of poe.com's LLM's are their integration with web search. The superpower of CoCalc.com's LLM's is the integration with computation (including high powered HPC VM's, GPU's, Jupyter Notebooks, LaTeX, R, etc.). For example, continuing our thread above:

But you can also generate code in Jupyter notebooks, that are either running in lightweight shared environment, or on high powered dedicated compute servers:

Finally, you can always check and see exactly how much every interaction costs:

Try it out today!!!

Run RStudio directly in your project

Open the "Servers" Tab to the left, then scroll down and click the "RStudio" button:

In a second, R Studio server will appear in another tab:

Simple as that. You can also run JupyterLab and VS Code just as easily.

Run RStudio on a compute server

If you need vastly more compute power (e.g., 80 cores for only $0.47/hour!!!), scroll up a little and create a compute server:

then:

After that, create the compute server and when it starts up, click the https link. You may have to copy/paste a token to access the RStudio instance.

As usual, there are also a ton of upgrades for the Python 3 (system-wide) environment, R, and various underlying Linux packages.

If you run into problems, please let us know in support. You can also always switch back to the previous environment in Project Settings → Control → Software Environment and select "Ubuntu 22.04 // Previous".

Update:

2024-03-29: a small patch update has been released, which mainly fixes a pandas vs. openpyxl incompatibility involving reading *.xslx files.

Click a button and CoCalc installs and runs JupyterLab, VS Code, or an X11 Desktop directly on the compute server.

If your compute server is geographically close to you, then using this application will have low latency.

Each application is running on the compute server and has full access to your files and any compute resources of the compute server. Any project collaborator can also access this link. Moreover, if you share the link with the auth token, then anybody you share it with can use the app (even if they do not have a cocalc account).

For JupyterLab, you must configure a DNS subdomain, which is easy to do in the Network section directly above:

For the X11 Desktop, almost no applications are installed by default. Fortunately, you can do apt-get install ... to install apps. For example, after apt-get install gimp, you can run gimp:

Select an intel machine type, e.g., n2-standard-2, then scroll down and check "Enable Nested Virtualization":

• Anaconda
• JupyterHub
• Kubernetes Node

Anaconda

The Anaconda image is a lightweight image with the conda command installed and configured (via mambaforge), and two channels, anaconda and conda-forge, enabled by default. You get Python 3.11 and can very easily install packages into your compute server's environment using the conda command, e.g., install Matplotlib:

(compute-server-1540) ~/anaconda$ conda install matplotlib

The packages you install are stored in /conda only on the compute server, so installing and using the packages is fast, and if you make the compute server disk large, you can install many packages.

JupyterHub

Th JupyterHub image is a single-node Kubernetes install of JupyterHub, which can be fully customized by you exactly as explained in the official docs (or email help@sagemath.com for support!). Click to create it, and wait for everything to install. It can take several minutes to start the first time, so please be patient. There is a random registration token which has to be entered to connect to JupyterHub; once you do that the default auth is that anybody can then sign in with any login/password (that's just the JupyterHub default). The default image is also very simple, but you can easily change it as documented above.

This is a single node deployment by default, but scaling up to multiple nodes does work, though it requires some copy/paste on the command line. (We will automate this in the future.)

Kubenetes Node

You can create a Kubernetes node. This is a single node Kubernetes cluster by default. However, you can join it to an existing cluster following the microk8s directions. E.g., you could expand a JupyterHub install to have multiple nodes.

There is a new option "Serial" that is visible for any running compute server:

Clicking the Serial button shows the serial console from when the compute server started running:

This shows you what happened as the VM booted up, including starting the various cocalc services, periodically reporting on status, etc.:

The serial console is rendered using xtermjs, using whatever color scheme you have configured for your terminal (in account prefs).

You can now make it so a compute server will automatically restart whenever it stops responding (for about a minute) for any reason, including crashing due to running out of RAM or if it is a spot instance that is killed due to a surge in demand. Just check "Automatically Restart" in the compute server configuration dialog:

This is especially useful for the "Spot" provisioning type, since they are up to 91% cheaper, and tend to be killed randomly between 12 hours and 1 week from when you start them. Spot compute servers with "Automatic Restart" enabled are ideal for hosting a powerful but affordable web service or a computation that you update periodically (e.g., using crontab), or checkpoint and can automatically resume.

Just create a compute server (starting at about a $0.01/hour) with the R image, click on the https link, paste in your random token, and you have the latest version of RStudio Server running, with full access to your files from your project and the full power of whatever compute server you're using.

This does not have any support for realtime collaboration or AI integration, etc. If you need all that, you can also just use a Jupyter notebook on the compute server:

This is not using X11 or anything like that. It's the normal open source RStudio Server web application.

For extra speed select your compute server to be in a region that is geographically close to you. When using RStudio all communication is directly between you and the compute server, so it'll potentially be much faster.

We were in booth 411, where we interacted with distinguished attendees from both academic institutes and esteemed research organizations like NOAA and the U.S. Naval Research Laboratory.

As a company dedicated to providing high-end, competitive resources for research, we are excited to announce the release of our new Compute Server functionality. This development will greatly benefit those working with large-scale ocean current models, similar big data applications, or graphically intensive simulations.

We would be delighted to walk you through our updated system and help you discover the increased efficiency, enhanced accessibility, and more powerful resources that our new Compute Server functionality brings.

This was an excellent opportunity to explore the tools CoCalc provides and to see what we can bring to your research endeavors.

Sincerely, -Blaec Bejarano, Chief Sales Officer, CoCalc by SageMath, Inc.

Mojo is a new programming language that "combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models."

In the tutorial, you will create a compute server, install Mojo in two minutes, use the Mojo Jupyter kernel, edit and run .mojo files and call Python code. Along the way you can try out any of the new features of Mojo and go through the Mojo intro manual to find out what this new programming language really feels like.

Try it in our LaTeX or Markdown editor: Insert → AI Generated Formula (or "AI Formula" button)

The description text can range from simplified algebraic notation, a mix of description and formula notation, up to just a few natural words describing the formula. Additionally, if some text in your document is selected, will be used as the input and replaced when inserted.

Examples

• text: product of k=1 to infinity of (N choose k) / (1+k)!

  is converted to $$\prod_{k=1}^{\infty} \frac{{N \choose k}}{{1+k}!}$$

  $$\prod_{k=1}^{\infty} \frac{{N \choose k}}{{1+k}!}$$

• text: "heisenberg uncertainty"

  is interpreted correctly and you immediately get the formula – no need to fiddle around with uppercase deltas and so on $$\Delta x \Delta p \ge \frac{h}{4\pi}$$

  $$\Delta x \Delta p \ge \frac{h}{4\pi}$$

• text: d/dx f(x) = d^2/dx g(x) + C

  transformed to $$\frac{d}{dx} f(x) = \frac{d^2}{dx} g(x) + C $$

  $$\frac{d}{dx} f(x) = \frac{d^2}{dx} g(x) + C$$

• text: sqrt(x^2 + y^2) < k logical-and x + y > 0

  two inequalities with a logical and $$\sqrt{x^2 + y^2} < k \land x + y > 0$$

  $$\sqrt{x^2 + y^2} < k \land x + y > 0$$

Here are two short clips showing this in action:

A familiar looking menu bar collects all available options for the edited document, the layout and the underlying file. Below that menu bar, a newly designed toolbar exposes commonly used menu items for quick access.

You can adjust which buttons are shown by clicking on the icon in the menu entry. This toggles its visibility in the row of buttons. You can also completely disable the manu toolbar via the menu for a specific type of editor.

Stay tuned for upcoming updates and as usual, please report problems via our help channel.

On top of various updates to many system packages and libraries, this update also tweaks how Octave output is processed. This should eliminate spurious extra characters, which are not properly processed by the kernel itself.

As usual, if you encounter any issues, you can switch back to the "Ubuntu 22.04 // Previous" edition. This configuration is in Project Settings → Project Control → Software Environment. Also, please contact us in support, such that we can investigate the problem.

Tabs View

The first layout mode is called "Tabs" and shows the open files in the same order as the tabs across the top. You can use drag and drop to re-order them, use the arrow buttons to change the ordering, or even use the filter box to help you find a tab more quickly.

Starring files

Starred files, indicated by the filled star icon, are kept in the list even when the file is closed – this resembles how bookmarks work. Toggle the "Starred" button at the top left to show or hide closed bookmarked files. To star a file, just click on the empty star on the left of the file name. To unstar it, click the filled star of an opened file. Note: unstarring closed files is not possible, because this leads to accidental unstarring.

The main use case is to mark often used files to get back to them later. They can serve as a static anchor point in a larger project with many files!

Folder View

The second layout is Folder. Instead of showing all tabs in the "natural" ordering, this view groups them by directory and sorts the files by name. This gives the files a consistent place.

Since directories are logical groupings of files, this view naturally inherits these groups from the folder layout.

The "Home" directory has a special place at the top. Clicking on the "(X)" close button of a directory means that all opened files in that folder are closed.

By starring a directory, it is kept in the list of tabs at all times. This is helpful to quickly open that directory in the full page file explorer: just click on the folder and you jump there immediately.

Typed View

Finally, these opened and starred files can also be grouped by their type. So, imagine you work with a couple of Jupyter Notebooks, they will be in that view at the top at all time.

Here are two screenshots, showing all starred files vs. only grouping the opened ones:

showing starred files:

no starring:

Finally: remember any time you open a file, the "current directory" in your project changes as well. This means you can get to see all files in that current directory, when you click on the "Explorer" or you can add files in the current directory in "New".

Let's start the year with a rather large software update. The default Ubuntu 22.04 based environment has Sage 10.2 and Julia 1.10 as default. As usual, you can still access older versions by using the versioned command-line utility – e.g. julia-1.9 – or switch the Jupyter kernel.

• (new) SageMath version 10.2 is the default now: 10.2 release tour. You can use the sage_select utility to switch what version to use in a Sage Worksheets or switch the kernel in a Jupyter Notebook.

• (new) Julia 1.10: 1.10 release notes: Use julia-<version> on the command line or a different kernel to switch between versions.

• (upd) system-wide, there are a lot of updates, not only the Python 3 based environment, but also various Linux utilities. E.g. gcc 12 is available now.

As usual, the version available up until this update is available under "Ubuntu 22.04 // Previous" in Project Settings → Control → Software Environment. Please let us know about major problems, such that we can try to address them with the next update!

There is also a new Jupyter Kernel for Python3: Python 3 (Colab), which is very similar to the Python environment at Google Colab. This makes moving notebooks from that service to CoCalc very easy. Additionally, if you're interested in running it on a GPU, launch your own Compute Server and select the "Colab" image.

Apart from the above, many system wide packages and software libraries across R, Julia, and Python 3 have been updated.

If you encounter any issues, please let us know. Use the "22.04 // Previous" image to switch back temporarily.

"As you may have already heard, starting December 1, we're slashing the pay-as-you-go rates across all our machines – making them more budget-friendly without any hidden terms."

At CoCalc, we recently finally launched pay as you go machines, which was one of our main development priorities for 2023. These are fully integrated with CoCalc, and were a huge amount of work to bring to market. I was terrified that Deepnote's major price cuts would make Deepnote a much better deal than CoCalc.

Here is how the Deepnote and CoCalc pricing compares:

Conclusion: CoCalc's prices are still highly competitive, even in light of Deepnote's major price cuts.

Also, spot instances do work very well for many applications. For more details and how to get these prices at https://cocalc.com, read the rest of this post.

CAVEAT: comparing RAM and vCPU is not necessarily easy. Maybe I'm completely wrong.

More Details

I don't know exactly what Deepnote means by the above machine specs. However, according to my benchmarks, one of the very best machines we offer via Google Cloud is the AMD EPYC Milan family. Their single core performance is excellent, and a vCPU is equivalent to an entire core, which makes them up to twice as fast as lot of "vCPU" options out there. We offer both spot instances and standard instances.

Performance: 16 vCPU and 64GB RAM

Our best pricing on an AMD EPYC with 64GB RAM and 16 cores is $0.59/hour for standard instances.

By selecting a region in Europe, the cost is only $0.12/hour for a spot instance. Spot instances may stop or not be available, but our stats so far show they often work well for days to weeks, perhaps because Google has built out such massive CPU capacity:

In CoCalc the region where the machine is located is transparent, so you can take advantage of the best prices in the world.

High Memory: 16 vCPU and 32GB RAM

Our analogue of "High memory" above is a t2d-standard-32 with 32 cores, 128B of RAM, and it costs $1.17/hour for a standard instance, or $0.23/hour for a spot instance.

Again, the best price on spot instances is in a different region than for standard:

GPU

Deep note offers a K80 GPU for $1.80/hour. We do not offer K80's on CoCalc since they are so old, but we have L4's that have the same 24GB of RAM and are a much newer architecture. Our GPU price is $0.93/hour for standard instances, and $0.30/hour for spot instances:

Conclusion: CoCalc's new prices are still competitive. Yeah.

Happy Holidays! 🎄

• You can run the server geographically close to yourself, which makes it potentially much faster
• Your data is not backed up as part of the rest of cocalc in any way, which may be important for some use cases involving privacy or just storing large amounts of data.
• You can use massive amounts of compute resources and disk space, with optimal high performance
• Cocalc-docker fully supports using all of CoCalc's own editors, in addition to JupyterLab and VS Code
• You can be root and install your own software
• You can run any Docker containers
• If something goes wrong, you can get hands on support.
• GPU support

See https://github.com/sagemathinc/cocalc-docker/blob/master/docs/cocalc.com.md for a detailed step-by-step tutorial.

The GPU support is extensive, offering variants including A100 80GB, A100 40GB, L4, and T4 GPUs with finely configured software stacks. These stack images include SageMath, Google Colab, Julia, PyTorch, Tensorflow and CUDA Toolkit, accommodating a versatile range of uses. The compute servers integrating these GPUs come at highly competitive pricing, particularly for spot instances. CoCalc's compute servers represent a massive enhancement to default projects, offering increased speed, flexibility, and computational power, transforming the way users can utilize CoCalc for their projects.

To set up a compute server in CoCalc, log into your project, create a compute server through the "Servers" button, selecting your desired software image and optionally a GPU. To use the server, create a terminal file or a Jupyter notebook, move it to the server through the upper left menu, and remember to sync files for editing during computations.

Finally, here is a quick tutorial on how to get started with compute servers on CoCalc:

1. Once logged in, navigate to your project where you intend to use the compute server.
2. Click on the "Servers" button on the left side of the screen and select "Create Compute Server".
3. You will be prompted to select the desired software image and optionally a GPU. A GPU is selected by default but you can disable it if you don't need one. If you are going to write code using CUDA libraries, choose the "Cuda Toolkit" image. If you want to accelerate PyTorch computations with a GPU, choose the "PyTorch" image. If you want to use SageMath, choose the Sage image.
4. Start your compute server.
5. If you want to use the Linux command line, e.g., compilers, etc., create a terminal file (one ending in .term) and using the upper-left menu, select your compute server. If you chose the 'Cuda Toolkit', then the 'nvcc' command will be available for compiling .cu code.
6. If you need to edit the files during your computations on the compute server, remember to click the 'Sync' button at the top left of the terminal for the files to get copied to your compute server.
7. If you chose the "PyTorch" image or similar, create a Jupyter notebook and move it to the compute server via the upper-left menu. You can then select a Jupyter kernel that's available on the compute server, and your Jupyter notebook will run there.

Remember, compute servers are billed by the second only when they exist.

Check out the release tour to learn what's new. E.g. you can now instantiate the 27 dimensional exceptional Jordan algebra:

O = OctonionAlgebra(GF(7), 1, 3, 4)
J = JordanAlgebra(O)
J

Exceptional Jordan algebra constructed from Octonion algebra over Finite Field of size 7 with parameters (1, 3, 4)

For more general information, visit the SageMath documentation.

In other notes, many tools and utilities have been updated and as a new addition, bun, a fast JavaScript runtime is available as well.

1. I don't see a warning about fees when I select "@GPT-4" in the chat window. Does the platform remind users about the fee before the chat is sent?

Anybody can select GPT-4 (in chat and other places), but the first time you use it, there is a big confirmation dialog. This lets you set a specific monthly spending limit (you can set anything you want), which is by default $0. You can always adjust this limit later at https://cocalc.com/settings/purchases under "Self-Imposed Spending Limits", where you can also see the rates.

The dialog also lets you add credit to your account, in case you don't have any, and you can check on the status of that credit at https://cocalc.com/settings/purchases. After you explicitly set a limit and add credit, you don't get explicitly asked again every time you use GPT-4. Also, on any day when you use GPT-4, you'll receive an email statement at the end of the day listing how much you spent (and this is easy to disable).

2. If a student uses GPT-4 once, will CoCalc default to GPT-4 thereafter?

Currently no. The default is always GPT-3.5. That said, several people have been requesting a way to default to GPT-4, to save themselves a click, so we will very likely make that an option sometime in the near future. But it will be possible to configure it either way.

From the "tokens" pricing scheme on OpenAI's site, it is difficult for me to get a good approximation for how much GPT-4 use would cost my students. I recognize that there are too many unknowns for a specific dollar amount, but can you give me any information that would help estimate the cost per semester? A sense of scale ($1 vs. $10 vs. $100 per semester) would be helpful.

Since all use is explicit and manual, e.g., via chat or clicking, in practice it's very difficult to use very much. My guess is that a typical student might use $10 for an entire semester worth of use. A typical interaction is a few cents, so hundreds of interactions cost about $10. You'll quickly get a sense of spend because it's listed in the daily statements mentioned above. For comparison, OpenAI charges $20/month for their GPT-4 chat site, and Microsoft charges $30/month for their CoPilot integration. The model in cocalc where you pay for what you actually use is more affordable.

Note that GPT-3.5 is significantly faster (and completely free to users, though it costs me), and for some things it's pretty good, so people often use it just because the output appears so quickly.

Some other notes:

• In case you're worried, it's also possible to fully or partly disable ChatGPT for students in your class, e.g., during an exam. That's in course configuration.

• We're planning to add other Large Language Models, e.g. Claude2 from Anthropic, pretty soon.

There are no major changes, just regular updates to many packages and binaries.

To buy a cash voucher code, visit https://cocalc.com/store/vouchers and do "Add Cash Voucher".

then fill out the number and description, and customize the voucher codes:

Then create your voucher codes:

You get this:

Go to https://cocalc.com/redeem and redeem your own code... thus getting your money right back (as credit in your account)!

Note that this has no impact on my balance -- I just made a $5 voucher, which reduced my balance by $5, then I redeemed it, increasing my balance back to exactly where it was:

I hope you find this useful. E.g., if you're teaching a workshop and you want everybody to have an easy way to upgrade their projects for a few hours or use GPT-4 for more sophisticated AI help, you can just issue each participant a $2 voucher...

Payments to add credit now work in your local currency anywhere in the world with a wide variety of local payment methods, instead of just credit cards! You can also buy a subscription without enabling any form of automatic payments -- you just have to manually add credit to cover the subscription periodically.

Another massive improve in our license system is that if you purchase a licenses and find that you need to increase or decrease the RAM or disk space or run limit (number of upgraded projects) or anything else at any time, you can just directly edit the license and your account will be debited or credited accordingly. If you need a license for only a week, or to extend an existing license, you can also just do that at any time using the balance in your account (you're charged the prorated difference).

I think this is much better than what we had before, and it's now fully live as you can see at

• https://cocalc.com/settings/purchases
• https://cocalc.com/settings/subscriptions
• https://cocalc.com/settings/statements

and in the screenshots below. These improvements to purchasing are the result of feedback from thousands of users over many years.

Purchases:

Statements:

Edit a license

Pay as you go project upgrade

GPT-4

This update includes the Macaulay2 Jupyter Kernel, which is a powerful tool for symbolic computation. Here is an m2 example notebook.

In addition to the new kernel, many new and updated packages are now available. For example, the Python3 (system-wide) environment now includes:

• GerryChain - a library for using Markov Chain Monte Carlo methods to study the problem of political redistricting.
• cirq - a library for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
• tequila - a high-level abstraction framework for quantum algorithms.

As usual, you can switch back to the previous 22.04 environment via Project Settings → Project Control → Software Environment: "Ubuntu 22.04 // Previous". Please report any issues you encounter!

Files

The files flyout hosts a compact file explorer that retains the familiar filter, sort, and hidden files functionalities. In addition, it introduces a terminal fully synchronized with your directory navigation. Any directory changes within the terminal are reflected in the interface and vice-versa. This synchronization can be disabled through a toggle button.

When one or more files are selected, file actions become available; these currently open the existing panels. This functionality will be further refined in future iterations. A double-click on a file opens an editor, echoing the usual behavior observed on traditional operating systems.

Log

A new feature is the presence of a button enabling you to load the full history. Similar to files, color-coded borders to the left signify recent usage (in the past few hours, last day, or past week) which assists in quickly identifying the recently modified files, either by yourself or your collaborators.

Servers

Our updated interface also encompasses a command button to restart the Sage Worksheet server.

Users (formerly known as "Collaborators")

The revamped interface offers improved control over project access. Future updates will streamline rough edges associated with the invite token and sandbox project components.

Upgrades

This flyout panel provides a succinct overview of your project quotas, their current usage, and limits. Below the quota overview, licenses and upgrades can be configured.

Settings

This new settings panel comprises a neatly organized and expandable list of all remaining project settings. This simplified representation makes it easier to focus on just the setting you intend to modify.

Future Developments

While the current flyouts might not fully embody all the features from large configuration pages, we assure you that these will soon be incorporated. Several additional elements, including Git integration, a project-wide chat, an improved homepage, and various minor tweaks are also under consideration. We value and look forward to your feedback.

The Save and TimeTravel buttons are improved for seamless file management. Moreover, all buttons will stay visible in non-focused panels – a feature that will benefit LaTeX users greatly. In addition, the left flyout panel is now resizable, featuring a number of other subtle improvements. But what's probably most exciting is the new capability of ChatGPT to stream its output in all situations, whether in side chats or when generating new notebook cells. You can now watch the AI response unfold in real-time as it is being written, significantly enhancing interactivity on the platform.

These updates are set to make your coding experience smoother, more convenient, and enjoyable. Don't forget to refresh your browser!

• Using @ChatGPT in chat no longer results in a notification badge counter increase
• Mojo code editing support (syntax highlighting).
• File tabs no longer resize when closing them, like with chrome, so it's easier to close many tabs.
• Improved Save and TimeTravel buttons
• All buttons now stay visible in non-focused panels, which is especially nice with LaTeX:
• The left flyout panel is now resizable, and has many other subtle improvements.
• ChatGPT streams its output in all cases now, both in side chats, and when generating new notebook cells, so you can see the response as it is written. E.g., via Home screen or +New --> "Generate Jupyter Notebook:

There is something similar at https://cocalc.com/config/account/api and ALSO in the settings page for all projects.

These newapi keys have an expire date, a name (which you can change at any time or repeat), the secret key itself doesn't get stored in the database (which is much more secure), and there are project specific api keys that only work for api calls for a specific project, rather than for everything. I left in the old api key functionality, but with messages that people should delete them, so the old keys still remain fully supported.

With the new api keys you can have up to 100 different keys active at once. A key can be set to expire at any time and then it is automatically deleted. You can edit the expire date and the name of the key at any time. It's a much better model. Behind the scenes we don't store the key in the database; instead, we just store a hash of it (the same sha-512 with 1000 rounds and salt as for passwords), so we can confirm somebody knows their api key without having to have the key in the database; this is much more secure. I also really like that I can make a key with a 1-day expire, play around with it, and know it's not just going to be a ticking time bomb.

Read more about the API here: https://doc.cocalc.com/api/ and https://doc.cocalc.com/api2/index.html

The motivation for doing this is that project-specific API keys are needed for some new functionality we're implementing right now that will support connecting external computers to a CoCalc project to provide much more powerful compute. Among other things, this will greatly expand the sort of compute we can offer to include GPU's and other vastly more powerful options, and also to support people plugging in their own compute resources.

With the flyout panel, you can now effortlessly explore files, conveniently check recently modified files, keep track of running processes, perform quick searches, and much more. This initial release is just the beginning, as we have plans to continuously enhance and refine the feature in the upcoming weeks.

Experience the efficiency and ease-of-use that the flyout panel brings to your projects on CoCalc. Try it out today and stay tuned for exciting updates in the near future!

Explore files	Running processes

Our team was at the SIAM Conference on Dynamical Systems in Portland, and we wanted to share some of the research that really stood out to us. It was a great chance to see the kinds of complex problems people are tackling right now.

Here are a few highlights that got us thinking:

• Alethea Barbaro’s work on collective motion was fascinating. She’s modeling how groups (like flocks or swarms) move when individuals have different sensing abilities. This is a huge challenge in multi-agent simulations. It immediately made us think about how you could use a tool like CoCalc to run a dozen parallel simulations, tweaking the sensing parameters in each to see how the group behavior changes without getting your local machine tangled up.

• Sunghwan "Sunny" Jung's presentation on animals and fluid instabilities was another great example of messy, real-world science. He explored how animals navigate and even use things like turbulence. Research like this is so interdisciplinary. You might need to run a fluid dynamics simulation, analyze observational data with Python, and build a mathematical model in a LaTeX paper, all for one project. It’s a perfect case for having all those different tools and files in one shared online space.

• We also really enjoyed the talks that went back to fundamentals. Hugh Hunt’s discussion on the physics of pendulum clocks and Alexandria Volkening’s deep dive into stability analysis were great reminders of how powerful the core principles are. This is the kind of stuff you want to code up from scratch in a notebook to really get a feel for it—and it’s a perfect teaching example to share with a student who can then play with the code themselves.

Going to conferences like this is incredibly valuable for us. Seeing the actual computational hurdles you face is what helps us figure out how to make CoCalc a more useful and practical tool. A huge thank you to the SIAM organizers for putting on such a productive event.

All the best,

The CoCalc Team

We're happy to announce that the Ubuntu 22.04 line of images became the default for new projects. You can update your existing projects to use this new image, or switch back to 20.04 any time – that's in Project Settings → Control → Software Environment.

Most notably, the system-wide Python 3 environment is much more recent, several Octave kernels are available, and many small changes make this a much better environment for modern scientific computing.

Updates for 20.04 will become less frequent and it will eventually be deprecated, just like with the lines before it. However, we'll keep it around in case you depend on older software or on some tools, which did not make it into 22.04.

For more details you can study our software environment inventory.

"Neural AI Search" is now live in cocalc. The actual application right now is minimal compared to what it could be. I just want to get the backend foundations in place, and make it so content starts getting indexed, before building a bunch of new frontend capabilities on this. Right now the only thing you can do is click on the Find page in a project, click "Neural Search" off to the right, and do a search in that directory. It searches only jupyter, tasks, chat, whiteboards, and slides that you have opened for at least 7.5 seconds after I made this live a few minutes ago. It then updates the backend search index as you edit them.

The potential with this is extensive, and this is just a VERY tiny step. E.g., the underlying thing could work across many projects whether or not they are running, and of course it would also be extremely useful to search only within a specific file (like this chat). Also, this provides the foundation to make it so when interacting with ChatGPT it can be aware of content across your files and in relevant technical documentation (e.g., sagemath docs from now instead of 2021).

Technical Architectural Remarks

The basic thing seems to work fine, and the design I finally came up with (after numerous painful iterations this week!) uses git and sync like trickery to I think be very efficient and robust, and the expense of an $\varepsilon$ chance of a wrong answer (which hardly matters for search).

In admin settings there is a new box:

When this is "no", everything is disabled, including any backend api's and frontend UI. When set to "yes", a person can put in the address and api key of a qdrant server, e.g., from https://cloud.qdrant.io/ or run their own, and then they automatically get neural network search working. This involves three tables:

• postgres: openai_embeddings_logs -- logs any time that somebody calls the openai embeddings api, and how much it costs. It has some "elaborate" throttling strategy to ensure that we don't spend too much...
• postgres: openai_embeddings_cache -- a cache of the expensive to compute map from text to a vector in $\mathbf{R}^{1536}$ that comes from the openai embeddings api. Entries in this cache expire after 6 weeks of not being touched. That said, postgresql seems to store vectors of doubles pretty compactly, and we aren't doing anything but just using this as a key:value cache.
• qdrant: cocalc -- a "vector collection" of embeddings and metadata

Yes, this is all available in cocalc-docker.

The "robust" part of the design is that if you delete any data from any subset of the above tables, things will just keep humming along fine - there's no dependence. Delete some of the cache and we just pay more (and things are a little slower), delete some of the vector database, and you'll just get less search results. This is very different than my original design, which tightly couple qdrant and postgres, in such a way that it was very easy for one to break the other.

The data model for qdrant uses a lot of techniques to ensure security and limited data access (similar to what we do with postgresql), which is fairly easy to do with qdrant, but NOT with more basic vector databases. It also, wouldn't have worked with qdrant back in Nov 2022, since they have improved a lot recently.

The final piece in this whole puzzle is that for cocalc.com, we run qdrant itself in our Kubernetes cluster, and have regular snapshots that we backup. Qdrant's design is very much NOT a pig -- it's written in tight memory efficient Rust, and uses quantization to massively reduce the space used to store vectors, so I think it'll scale pretty well for us.

There's also the potential of providing this vector search capability via our api on a "pay for what you use" basis, and that could be of interest as its own product, since I developed a way to have a large number of independent organized vector databases that are "multi-tenant", so the cost is excellent per user. It's something to explore for "cocalc.ai", since it could be useful for to sell for a lot of people. It's actually already available (for free), and just not documented.

First, we kicked off the month at the Startup Grind Global Conference 2023 in Redwood City, exploring the power of Big Data and building recession-resilient startups. I connected with tech innovators and enterprising entrepreneurs, energized by the spirit of collaboration and shared insights.

Next, we ventured into the realm of high-energy physics at the American Physical Society (APS) April 2023 Meeting. We engaged in stimulating discussions on fusion experiments at Lawrence Livermore National Laboratory, diversity in STEM fields, and learned about the groundbreaking James Webb Space Telescope 🌌.

Then, I immersed myself in the world of data science at PyData Seattle 2023 💻. This exceptional event offered incredible talks and hands-on workshops covering a wide range of topics, from scaling Altair visualizations with VegaFusion to the open source quantum ecosystem.

Finally, I am currently attending the JupyterCon 2023 in Paris, where CoCalc is proudly attending due to our contributions within the Jupyter ecosystem 🌐. It was truly a wonderful opportunity to engage with potential hires, partners, and other professionals in the data science field while strengthening CoCalc's brand visibility.

A heartfelt thank you to my connections, new friends, and colleagues I met along the way. As we continue our journey, let's pave the path for an even brighter, more collaborative future! 🤝💡

Stay up to date with our events here and keep the collaboration flowing!

Can't wait to see you all at the next events! Until then, stay curious and collaborative!

1. 💡 Jupyter API and kernel pool: There have been significant improvements to Jupyter notebooks, including the introduction of the Jupyter API and a new kernel pool, providing a more seamless and efficient experience to users. You can also embed executable code anywhere in CoCalc where you use Markdown by just making a fenced code block.
2. 📖 First Steps Guide: A helpful First Steps Guide is now available to guide newcomers and make it easier for them to dive into CoCalc. Click "Start the first steps guide" at the top of your cocalc project.
3. 🌟 Tab completion: Tab completion for LaTeX, Python, JavaScript, and other languages has been introduced, making coding and document editing faster and more convenient. Use the tab key when editing code or latex outside Jupyter.
4. 🔧 "Help me fix this..." for LaTeX and Sage Worksheets: A new very popular feature using ChatGPT, which helps you quickly identify and fix errors in LaTeX documents and Sage Worksheets, improving productivity. Whenever an error occurs, click a button, and get a context sensitive suggestion about how to fix it.
5. 🔍 Better share server searching and sorting: It's now even easier to find and organize your work with improved search and sorting capabilities on the share server. Browse now! You can also run and edit code in any published notebook, directly from the share server, without having to sign in or make a copy.
6. 📝 Task lists: Task lists have been upgraded to a frame editor, allowing you to view a single task list in multiple ways simultaneously. In particular, you can splits your list horizontally or vertically and set separate search parameters for each frame. You can also easily analyze any subset of tasks using ChatGPT.
7. 🤖 OpenAI ChatGPT integration: You can now integrate OpenAI ChatGPT with your Jupyter notebooks or Linux Terminal in CoCalc, opening up endless possibilities to leverage AI in your work.
8. 🎙️ CoCalc Slides: Create amazing presentations with CoCalc Slides, which supports Jupyter code and LaTeX math in your slides. These are based on the whiteboard but with a presentation mode and specific sized slide.
9. ⏰ Better display of points in time: Easily switch between relative and absolute time displays for improved clarity and understanding, anywhere that times are displayed in CoCalc.
10. 🎛️ Vouchers: Transferable codes for licenses can now be renewed later, giving more flexibility to users. Did you read this far? If so, send us a message to try out a voucher for free!

These developments make CoCalc an even more powerful and user-friendly platform for those seeking an all-in-one fully collaborative scientific computing environment! 🎉

I just spent the morning bringing back the "First steps guide".

You probably have it off if you're reading this, but to see it check this box in account prefs:

It looks like this at the top of any project:

When clicked, it copies these files over:

https://github.com/sagemathinc/cocalc/tree/master/src/smc_pyutil/smc_pyutil/templates/first-steps

NOTE: If you haven't restarted your project then it copies files from the library instead, which are a lot older.

The content is still relatively dated and it'll get further updates soon.

You can try 22.04 right now by going to Project Settings → Project Control → Software Environment: and select "Ubuntu 22.04 (Current)". You can switch back any time as well.

As always, please let us know about issues you encounter.

This was partly inspired by Terry Tao's recent remark about ChatGPT: "Just being able to resolve >90% of LaTeX compilation issues automatically would be wonderful..."

When clicked, you get a chat like this:

The "Details" contains the error, what you're doing (latex), and a selection from the file to help chatgpt better assist you.

Here's another example:

As a reminder, TimeTravel is another feature of CoCalc that helps in fixing errors -- if you had everything compiling 5 minutes ago, just zip back in time and see what you did to mess things up.

• To benefit from this optimization, you need to restart your project (or start a new one). Refreshing your browser will not make any difference.
• The very first time you start your project and open a notebook, there will be no difference except for one extra kernel starting in the background (that's the pool). Moreover, a file ~/.config/cocalc-jupyter-pool will be created with the parameters of that kernel.
• If you then open another notebook with the same kernel, running code should start MUCH more quickly. Additionally, "restart and run all" in a notebook should be significantly faster than before (e.g., less than a second instead of 10 seconds, say, for Sage!).
• If your project stops and you start it up again later, your first use of a kernel should be MUCH faster, assuming you're using the same kernel as before and you haven't changed any custom environment variables. Under the hood, whatever was stored in ~/.config/cocalc-jupyter-pool will be started next time.

That's it! One interesting thing I needed was code to generate code for each language that would set custom environment variables on the fly. I had something that would generate code to change directories, and I pointed GPT-3.5 at that code and said, "rewrite this to instead generate code for custom environment variables..." and it worked perfectly on the first try.

News items are available at cocalc.com/news and as notifications in the application itself. You can also grab the RSS feed to ingest it in a reader of your choice. In the future, we plan to send out newsletters as well.

You can now click a button and ChatGPT will automatically try to figure out how to fix the error and tell you in a chat next to your main document.

Then in the Chat on the side, ChatGPT replies:

Click it to start a chat with ChatGPT in order to get a detailed explanation what this code does. You can even ask follow up questions.