Run Code Online: Sandbox Limits for Python, JS, Java, Go, C++

#What online runners are actually good for

Online runners are good at exactly three things: checking whether a snippet compiles, testing a small algorithm, and sharing a reproducible example. Anything longer than about 20 lines usually belongs in a local environment.

These cases pay off the most:

• Learning a language and testing one construct: a list comprehension, a slice, a pointer, a closure
• Running boundary cases of an algorithm before you copy it back to your editor
• Working on someone else's machine where nothing is installed
• Sending a colleague a bug reproduction they can run in one click

#What container isolation means

Isolation means your code does not run on your machine or on a shared box - each request starts a sandbox container that is destroyed as soon as the run ends. It gets its own filesystem, its own process space and hard resource caps.

Four practical consequences follow:

• Files you write exist only for that run; the next run sees a clean container
• Nothing you install or export survives into the next execution
• Wall time, memory and process count are capped, and a process that exceeds them is killed
• The execution container has networking disabled, so pip install, go get and npm install all fail

Java, Go, C++ and Shell are handled by a self-hosted execution gateway. It listens on a local port only, accepts requests from this site's pages only, and runs each submission in a fresh isolated container.

If that gateway is unavailable, the page falls back to a third-party execution service, and your code leaves this site.

#Java, Go, C++ and Shell each fail differently

Most failures in compiled languages are about the entry point, not the logic: Java looks for a class name, Go looks for package main, C++ needs its headers. Get those aligned and you remove half the errors.

#Java: the class name has to match the entry file

Java requires a public class to live in a file of the same name. The entry filename in the sandbox is fixed, so the easy fix is to drop public or simply call the class Main.

// Fails: a public class must match the entry file name
public class Test {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

// Works: no public modifier, so the fixed entry file accepts it
class Main {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

#Go: package main and unused imports

A Go program runs only if it declares package main with a func main. On top of that, every imported package must be used, or compilation stops immediately.

// Fails: no package declaration at the top of the file
import "fmt"

func main() {
    fmt.Println("hello")
}

// Works: complete entry declaration
package main

import "fmt"

func main() {
    fmt.Println("hello")
}

#C++ and Shell

C++ needs an explicit #include for every symbol you use, and the compiler standard is fixed on the backend - there is no -std or -O switch in the interface, so code that needs a newer standard may not build.

Shell has no interactive terminal, so a script has to run to completion unattended. Anything needing a system service or administrator rights simply is not available.

#What online runners cannot do

Four jobs do not belong in an online runner: long computations, network access, persistent files and third-party packages. These are not configuration gaps - the sandbox is designed without them.

#Read the error: sort it into one of five buckets

Almost every online failure is a compile error, a timeout, a resource limit, a missing dependency or an encoding problem - and the fix is different for each.

#Which tool for which job

#Frequently asked questions

#Is it safe to run code online? Can I paste company code?

No. A sandbox keeps the code from touching your machine; it does not make the code confidential. Java, Go, C++ and Shell submissions are sent to the execution gateway, and fall back to a third-party service if the gateway is down. Python and JavaScript stay in your browser, but the same advice applies: no keys, no tokens, no real data. When you need to reproduce production logic, replace the sensitive parts with fake values.

#Why is the first Python run so slow?

Because the runtime loads in your browser. Pyodide downloads and initialises the runtime on the first run, which takes roughly 10-30 seconds, and every run afterwards returns in about a second. If it is slow every single time, check whether your browser is caching the runtime files.

#Can I install pip or npm packages in the sandbox?

No. The execution container has networking disabled, so installers and downloads fail. Code that depends on a third-party library either needs a standard-library rewrite or a local machine.

#Java keeps complaining that the class name does not match the file. What do I change?

Drop the public modifier on the entry class, or rename the class to Main. A public class must match its filename, and the sandbox uses a fixed entry filename, so removing public is the simplest fix.

#The program hangs and never prints anything. Where is it stuck?

Check input first. An online runner has no interactive terminal, so a program blocking on standard input simply waits until data appears in the stdin box. If input is not the cause, look at loop exits and recursion base cases. Both problems look identical from the outside: nothing is printed until the time limit kills the process.