Lightweight JavaScript/Node.js IDE - Run JavaScript/Node.js Code Online

Write, run, and debug JavaScript/Node.js in a lightweight online IDE with multi-file editing, persistent workspaces, runtime libraries, sharing, and live collaboration.

Version

Pre-installed Libs

🚀 334,705 total executions (316 this month)

Udemy Affiliates: Learn JavaScript/Node.js to upgrade your skills

Loading…

⚡ About This JavaScript (Node.js) Online Executor

The CodeUtility JavaScript Executor lets you write and run modern JavaScript code right in your browser - instantly and without any setup. It uses real Node.js environments to execute your code securely in a sandboxed container, supporting versions 16, 18, and 20.

This tool is perfect for testing Node.js snippets, exploring ES6+ syntax, or learning core JavaScript programming concepts such as loops, functions, arrays, promises, and async/await behavior.

You can also use it to validate algorithms, debug small scripts, or experiment with runtime logic without installing Node locally. It’s ideal for learners, backend developers, or anyone who needs a fast, browser-based way to run JavaScript code.

More than a code runner

Use a multi-file editor, an isolated execution terminal, runtime-specific libraries, persistent workspaces, sharing, and real-time collaboration from the same executor.

How to use this executor?

Choose a runtime, open or create a file, write your code, and select Run. Output appears in the terminal, while signed-in users can keep files in a workspace, install libraries, and collaborate through shares.

Select a version and edit the current file or open another workspace file.
Run the code, provide input in the terminal when requested, and review saved run history.
Use libraries, workspace tools, sharing, and chat when your task needs more than one snippet.

Start coding

VersionSelect a runtime before running. Installed libraries belong to the selected language version.
Open files lists unopened text files. Select one to open it in an available editor tab.
Run executes the active file with its workspace available to the program.
Stop ends the current execution before its time limit.
Advanced Mode opens the IDE layout with a file explorer and movable, resizable terminal.

Workspace and libraries

New file creates a file in the selected parent directory and opens it in the editor.
New folder creates a directory, up to the supported nesting depth.
Upload files adds one or more safe files to a directory.
Download saves a file or a zipped directory to your device.
Copy duplicates a workspace file or directory.
Rename changes a file name and updates its open tab and history.
Move relocates an item; files and directories can also be dragged.
Delete removes an item after confirmation and closes its open editor tab.
Pre-installed Libs shows packages already included in this runtime.
Add Lib installs a private package for your account and selected runtime.

Terminal and assistance

Run history opens previous and next saved outputs.
Run with switches Python between the execution server and Browser Python. Browser Python cannot use workspace files or server-installed libraries.
Copy output copies the current terminal text.
Clear output removes all saved run outputs after confirmation.
Explain summarizes the active code.
Recents opens recent explanations and results.
Settings changes fonts, themes, and visible toolbar buttons.

Sharing and collaboration

Share publishes the current file, a directory, or the whole workspace as a snapshot or live workspace. You control link access and who may save changes.
Logs records saved collaborator actions in a shared workspace.
Share chat lets signed-in participants message, mention people, share code blocks, and see online or typing members.
Live collaboration shows collaborator cursors and saved file updates. View-only users can load the latest version or keep temporary edits.

Quotas and limits

Execution time is limited to 20 seconds per server run. Use Stop when you want to end it sooner.
Workspace storage allows 100 files, 100 directories, and 10 MiB total for each signed-in user workspace and language.
Files and folders are limited to 1 MiB per file and 5 nested directory levels. Files generated by your code follow the same quota.
Private libraries are limited to 10 installed packages for each account and runtime.
Share snapshots can contain up to 100 files, 1 MiB per file, and 2 MiB total.
Share invitations support up to 25 people per share, with access and saving permissions managed separately.
Share chat allows 2,000 characters per message and 10,000 messages per share.
Quota enforcement also applies while code is running. A write that exceeds file count, size, storage, or nesting limits is rejected safely.

Good to know Only run code and install packages you trust. Execution is isolated and limited, but your program can still modify files inside a writable workspace up to its enforced quota.

💡 Node.js Basics Guide for Beginners

1. Declaring Variables and Constants

Use let or const for block-scoped variables. const is used for constants.

let x = 10;
const PI = 3.14;
let name = "Alice";
let isActive = true;

2. Conditionals (if / switch)

Use if, else if, else or switch for control flow.

let x = 2;
if (x === 1) {
  console.log("One");
} else if (x === 2) {
  console.log("Two");
} else {
  console.log("Other");
}

switch (x) {
  case 1:
    console.log("One");
    break;
  case 2:
    console.log("Two");
    break;
  default:
    console.log("Other");
}

3. Loops

Use for, while, and forEach to iterate over data.

for (let i = 0; i < 3; i++) {
  console.log(i);
}

let n = 3;
while (n > 0) {
  console.log(n);
  n--;
}

4. Arrays

Use arrays to store ordered lists of values. Access them with indexes.

let fruits = ["apple", "banana", "cherry"];
console.log(fruits[0]);
console.log(fruits.length);

5. Array Manipulation

Use methods like push, pop, slice, and reverse.

fruits.push("kiwi");
fruits.pop();
console.log(fruits.slice(0, 2));
console.log(fruits.reverse());

let squares = [1, 2, 3, 4, 5].map(x => x * x);
console.log(squares);

6. Console Input/Output

Use console.log for output and readline module for input.

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question("What's your name? ", name => {
  console.log(`Hello, ${name}`);
  rl.close();
});

7. Functions

Functions can be declared or expressed. Arrow functions are often used in modern JavaScript.

function greet(name) {
  return `Hello, ${name}`;
}

const add = (a, b) => a + b;

console.log(greet("Alice"));
console.log(add(2, 3));

8. Objects (Maps)

Objects store key-value pairs. They are similar to dictionaries or maps.

let person = { name: "Bob", age: 25 };
console.log(person.name);
console.log(person["age"]);

// ES6 Map
const map = new Map();
map.set("a", 1);
console.log(map.get("a"));

9. Exception Handling

Use try, catch, and finally to handle errors safely.

try {
  throw new Error("Something went wrong");
} catch (e) {
  console.log(e.message);
} finally {
  console.log("Cleanup if needed");
}

10. File I/O

Use Node.js's fs module to read and write files.

const fs = require("fs");

fs.writeFileSync("test.txt", "Hello File");
const data = fs.readFileSync("test.txt", "utf8");
console.log(data);

11. String Manipulation

Use methods like trim(), toUpperCase(), replace(), and split().

let text = "  Hello World  ";
console.log(text.trim());
console.log(text.toUpperCase());
console.log(text.replace("Hello", "Hi"));
console.log(text.split(" "));

12. Classes & Objects

ES6+ supports OOP with class syntax.

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `Hi, I'm ${this.name}`;
  }
}

const p = new Person("Alice");
console.log(p.greet());

13. References

Objects and arrays in JavaScript are passed by reference.

function update(arr) {
  arr.push("changed");
}

let data = ["original"];
update(data);
console.log(data);  // ["original", "changed"]