ForeverVM

What is ForeverVM about?

ForeverVM provides an API and command‑line interface for creating and interacting with stateful Python "machines". Each machine runs one instruction at a time, preserving its execution state across sessions, and can be swapped to disk when idle, enabling truly long‑running REPL sessions.

How to use ForeverVM?

1. Obtain an API token – request one via the project maintainer.
2. Log in via the CLI:

   npx forevervm login
   

3. Start a REPL (creates a new machine):

   npx forevervm repl
   

   • To reconnect to an existing machine, pass its name: npx forevervm repl <machine_name>.
4. List machines:

   npx forevervm machine list
   

5. Use the SDK (Node.js/TypeScript):

   import { ForeverVM } from '@forevervm/sdk'
   const fvm = new ForeverVM({ token: process.env.FOREVERVM_TOKEN })
   const repl = fvm.repl()
   const result = await repl.exec('4 + 4')
   console.log('result:', await result.result)
   

   • Machines can be created with tags and memory limits via fvm.createMachine({...}).

Key features of ForeverVM

• Stateful execution – each machine retains variables, imports, and environment across instructions.
• Infinite lifespan – idle machines are persisted to disk and revived on demand.
• Secure sandboxing – code runs in isolated containers to prevent host compromise.
• CLI & SDK – interact via a friendly command‑line REPL or programmatically with the TypeScript SDK.
• Tagging & filtering – organize machines with custom tags for easy retrieval.
• Memory limits – constrain resources per machine (e.g., 512 MB).

Use cases of ForeverVM

• AI‑generated code testing – execute snippets produced by language models without risking the host.
• Long‑running data analysis – keep stateful notebooks alive across sessions.
• Education and tutoring – provide persistent coding environments for students.
• Prototype services – spin up lightweight, isolated Python back‑ends on demand.
• Automated scripts – run scheduled or event‑driven Python code in a safe container.

FAQ from the ForeverVM

Q: Do I need to manually stop a machine? A: No. Machines automatically swap to disk when idle and are removed according to the service’s retention policy.

Q: How is security enforced? A: Code runs inside sandboxed containers with restricted filesystem and network access, isolating it from the host.

Q: Can I run non‑Python code? A: The current platform is Python‑only; other runtimes are not supported.

Q: How do I set resource limits? A: Use the memory_mb field when creating a machine via the SDK.

Q: What happens to stdout/stderr? A: Execution results include an async iterator of output objects, exposing both stdout and stderr streams.

foreverVM

repo	version
cli
sdk

foreverVM provides an API for running arbitrary, stateful Python code securely.

The core concepts in foreverVM are machines and instructions.

Machines represent a stateful Python process. You interact with a machine by running instructions (Python statements and expressions) on it, and receiving the results. A machine processes one instruction at a time.

Getting started

You will need an API token (if you need one, reach out to paul@jamsocket.com).

The easiest way to try out foreverVM is using the CLI. First, you will need to log in:

npx forevervm login

Once logged in, you can open a REPL interface with a new machine:

npx forevervm repl

When foreverVM starts your machine, it gives it an ID that you can later use to reconnect to it. You can reconnect to a machine like this:

npx forevervm repl [machine_name]

You can list your machines (in reverse order of creation) like this:

npx forevervm machine list

You don't need to terminate machines -- foreverVM will automatically swap them from memory to disk when they are idle, and then automatically swap them back when needed. This is what allows foreverVM to run repls “forever”.

Using the API

import { ForeverVM } from '@forevervm/sdk'

const token = process.env.FOREVERVM_TOKEN
if (!token) {
  throw new Error('FOREVERVM_TOKEN is not set')
}

// Initialize foreverVM
const fvm = new ForeverVM({ token })

// Connect to a new machine.
const repl = fvm.repl()

// Execute some code
let execResult = repl.exec('4 + 4')

// Get the result
console.log('result:', await execResult.result)

// We can also print stdout and stderr
execResult = repl.exec('for i in range(10):\n  print(i)')

for await (const output of execResult.output) {
  console.log(output.stream, output.data)
}

process.exit(0)

Working with Tags

You can create machines with tags and filter machines by tags:

import { ForeverVM } from '@forevervm/sdk'

const fvm = new ForeverVM({ token: process.env.FOREVERVM_TOKEN })

// Create a machine with tags
const machineResponse = await fvm.createMachine({
  tags: { 
    env: 'production', 
    owner: 'user123',
    project: 'demo'
  }
})

// List machines filtered by tags
const productionMachines = await fvm.listMachines({
  tags: { env: 'production' }
})

Memory Limits

You can create machines with memory limits by specifying the memory size in megabytes:

// Create a machine with 512MB memory limit
const machineResponse = await fvm.createMachine({
  memory_mb: 512,
})