𝐓𝐡𝐞 𝐫𝐚𝐭𝐡𝐞𝐫𝐧𝐨𝐭 𝐖𝐞𝐛 𝐋𝐢𝐧𝐤𝐞𝐫

Rathernot takes all your web files and smushes them into a single executable binary. It's a bundle bundler (or "linker" if you don't want to sound crazy).

There is no server, there is no client. You just write code and rathernot figures out where to run your code--in the browser or on the server. Rathernot does this by analyzing your code with SWC compiler extensions and injecting in a thin "operating system" that stitches together your client and server code via http requests.

An example:

import { Service } from 'rathernot';

const serviceLogger = Service({
  log: async (str) => {
    console.log(`Service logging str from client: ${str}`);
  }
});

async function main (root) {
  await serviceLogger.log('a client accessed the site!');
  const text = document.createTextNode("I logged something!");
  const header = document.createElement("h1");
  header.appendChild(text);
  root.appendChild(header);
}

In this example we print a simple message in the browser while logging a message on the server. The server logging code is split off from the rest of the program and only runs inside node.

A more realistic example can be seen in examples/filesystem, which is a simple browser based file system explorer.

How does it work?

Rathernot uses SWC's rust plugin API to "color" your code as either server or client. Then it passes the client and server code to esbuild, which constructs a client and server bundle. Then rathernot takes those two bundles and wraps them inside a thin "web operating system" and virtual filesystem inside the output .rn file.

The output "binary" is just a javascript file with a node #!.

Running it

Right now you have to build some pieces from source:

requires: node (16ish+), rust/cargo(1.58ish+)

inside linker/: npm install

inside linker/swc/service-injection/: cargo install (maybe?? I am not good with rust?)

inside linker/: npm run build

(you may need to chmod +x build.sh first)

Then: node linker/cli/index.js examples/logger.js && ./logger.rn

go to the app

Note: you can just execute the .rn file because it has a #! pointing to your node binary. You should node ./logger.rn in deployed environments. (or better yet, use a daemon)

Why?

The front end web as it exists today requires all users to build a heterogeneous distributed system (client and server). This has a few very bad consequences:

• building even trivial web apps is complicated (multiple files, technologies, platforms...)
• deploying web apps is complicated
• users can't share web apps because of the complication of distributing a client and a server. This has effectively meant users do not share web apps, only component libraries.

Rathernot provides a platform users can target to produce single binaries that can be built, run, and distributed using dead simple techniques.

It's also really cool :D

Todo list:

Syscalls

• Environment (provide environment variables)
• Secrets (provide environment variables, better)
• Lib (or some way to build a "library" instead of an "app"; probably mutually exclusive with "main") requires namespacing
• Service state / Service closures (cookies, browser storage)
• Include (some way to bring in static resources)

Optimizations

• CDN optimization (don't bundle dumb things to bundle like react)
• server externals (identify client-only deps and don't bundle them)

CLI

• config overrides for:
  • esbuild
  • swc
  • rathernot
• supply env in CLI (port=4000)

RNOS

• better error handling
• stack traces
• source maps
• https / certs

Docs

• docs

Testing

• OSX
• Windows
• integration test
• Typescript

Publishing

• npm build & install story
• contributing guidelines
• discord

Bugs

• mime types
• esbuild warnings when using imports that have no export
• empty responses from server crash rnos client json parsing