Actually Run Javascript Everywhere
Bare is a small and modular JavaScript runtime for desktop and mobile. Like Node.js, it provides an asynchronous, event-driven architecture for writing applications in the lingua franca of modern software. Unlike Node.js, it makes embedding and cross-device support core use cases, aiming to run just as well on your phone as on your laptop. The result is a runtime ideal for networked, peer-to-peer applications that can run on a wide selection of hardware.
import { createServer } from 'bare-http1'
const server = createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' })
res.end('Hello From Bare!\n')
})
// starts a simple http server locally on port 3000
server.listen(3000, '127.0.0.1', () => {
console.log('Listening on 127.0.0.1:3000')
})
// install with `npm i bare-http1`
// and run with `bare http-server.mjs`import { createHash } from 'bare-crypto'
import { readFile } from 'bare-fs/promises'
const hash = createHash('sha256')
// ensure you have a `package.json` file for this
// test!
hash.update(await readFile('package.json'))
const digest = hash.digest('hex')
console.log(digest)
// run with `bare read-n-hash-file.mjs`import { pipeline } from 'bare-stream/promises'
import { createReadStream, createWriteStream } from 'bare-fs'
import { createGzip } from 'bare-zlib'
// ensure you have a `package.json` file for this test!
await pipeline(
createReadStream('package.json'),
createGzip(),
createWriteStream('package.json.gz')
)
// run with `bare streams-pipeline.mjs`/* global Bare */
const { Thread } = Bare
const { isMainThread } = Thread
if (isMainThread) {
const worker = new Thread(import.meta.url, { data: 'beep' })
console.log('Joining Thread')
await worker.join()
console.log('Thread exited')
} else {
console.log('Log from Thread')
}
// run with `bare threads.mjs`Why choose Bare?
ESM & CommonJS Interop Support
Want to require() an ESM module? Bare supports both ESM and CommonJS modules using the same module resolution algorithm. ESM modules can use CommonJS modules and vice versa.
const { foo } = require('./esm')
foo().then(() => console.log('done'))await new Promise((resolve) => setTimeout(resolve, 1 * 1000))
console.log('After top-level await')
export async function foo () {
await new Promise((resolve) => setTimeout(resolve, 2 * 1000))
console.log('foo')
}Forget Upgrade Anxiety
Bare provides no standard library beyond the core JavaScript API available through the Bare namespace. Builtin modules like fs are a separate module bare-fs, so you have control over your code. Legacy libraries can be gracefully upgraded as needed allowing your codebase to be refactored, upgrading dependency versions in sync with your code.
const fs = require('bare-fs') // Uses current version w/ `copyFile`
const legacy = require('./legacy')
console.log('[index.js] fs.copyFile', fs.copyFile) // defined
legacy()const fs = require('bare-fs') // Uses 3.0.2 w/o
//`copyFile`
module.exports = function test () {
console.log('[legacy/index.js] fs.copyFile', fs.copyFile) // undefined
}{
"main": "index.js",
"dependencies": { "bare-fs": "3.0.2" }
}Simple Native Addon Support
By abstracting over both the underlying JavaScript engine using libjs and platform I/O operations using libuv, Bare allows module authors to implement native addons that can run on any JavaScript engine that implements the libjs ABI and any system that libuv supports. Virtually all N-API symbols are available as well and are built on top of libjs.
const binding = require.addon()
console.log(binding) // Hello addonBuilt for Mobile
Embedding a JavaScript runtime on mobile is easy with Bare Kit. Bare Kit allows you to create "worklets" or isolated Bare threads which expose an IPC with bindings for Android and iOS. With React Native, you install `react-native-bare-kit` and create a `Worklet` instance passing the JavaScript you want to run.
import { Worklet } from 'react-native-bare-kit'
const worklet = new Worklet()
worklet.start('/app.js', `
const { IPC } = BareKit
IPC.setEncoding('utf8')
IPC.on('data', (data) => console.log(data))
IPC.write('Hello from Bare!')
`)
const { IPC } = worklet
IPC.setEncoding('utf8')
IPC.on('data', (data) => console.log(data))
IPC.write('Hello from React Native!')Everything is a Module
At its core, Bare is minimal—no bloated standard library, no assumptions about how you’ll build. Instead, it gives you the freedom to compose your environment from a growing ecosystem of modules. Each module is small, purposeful, and designed to work seamlessly within the Bare runtime. No hidden dependencies, no unnecessary overhead—just building blocks you control.
Need filesystem access?
npm install bare-fsWant to handle HTTP requests?
npm install bare-http1Build a Bare, Runtime
Dont wait for V8's garbage collection, swap it out for QuickJS's reference counting memory strategy. Bare can support many engines (JavaScriptCore, V8, QuickJS) and any future engines as long as they implement a minimal js bindings to C API via libjs. Customizing Bare to fit your hardware requirements, allows your program to be run on any device, desktop, mobile, microcontroller, etc. Write once, run forever.
What Can You Build with Bare?
-
Peer-to-Peer Applications
Bare is perfect for any app that requires direct user-to-user connections. Think file sharing, collaborative tools, streaming, real-time communication—without the need for servers. Build apps like Keet or Pear, which allow users to communicate, share, and collaborate directly with each other.
-
Decentralized Networks
For developers building decentralized networks or even blockchain-adjacent solutions, Bare provides an optimized environment without the energy costs and complexities of consensus-driven blockchains. Whether it’s for decentralized finance, open data sharing, or private networking, Bare gives you the control and flexibility you need.
-
High-Efficiency
Data SharingBare’s streamlined runtime is ideal for high-volume data applications, like distributed media libraries, peer-powered games, or live video streaming. You can share, stream, and sync data across peers quickly and securely.
Why Now?
Bare isn’t just a runtime—it’s a foundation for the future of the internet. Where Node.js requires servers, Bare makes them obsolete. Bare can be run on any device with minimal requirements. And using Pear with the Holepunch stack's peer discovery, direct data sharing, and decentralized networking, Bare lets you build applications that connect users directly, safely, and seamlessly.