Hardware target.
Bare metal WebNux.

WebNux 1.2.0 runs on 10 hardware CPU architectures plus the browser. Flash a kernel image to real hardware and boot it directly — no OS underneath, no hypervisor. The same Webware architecture that powers the web kernel also drives bare-metal machines.

Flashing & Boot

Choose the right method for your hardware:

# x86_64 UEFI
cp BOOTX64.EFI /boot/EFI/BOOT/BOOTX64.EFI

# ARM32 Android (fastboot)
fastboot boot kernel.img

# RISC-V 32 — build then U-Boot
./build_riscv32.sh
# then in U-Boot:
fatload mmc 0 0x80000000 kernel-riscv32.img
bootm 0x80000000

Hardware Drivers

WebNux 1.2.0 includes the following hardware drivers. All drivers include x86-specific inline assembly guards so the kernel builds cleanly on every architecture.

Architecture-specific code

Some subsystems have architecture-specific implementations:

Filesystems

WebNux includes a VFS layer with two filesystem implementations:

kernel-os.js
Full WebNux kernel.

The default kernel — all subsystems merged into one file. Boots with a black screen, initialises every layer (PMM, VMM, BSD sockets, SysV IPC, capabilities, ELF loader, kprobes, /proc, ACPI, cpufreq, KMod), then fires onReady(). Exposes both WebOSKernel and the unified WebNux namespace.

Getting started

Drop in the script tag and call onReady(). The kernel handles its own boot sequence.

<script src="https://webnux.pages.dev/kernel-os.js"></script>
<script>
  WebOSKernel.onReady(kernel => {
    // your OS starts here
    document.body.innerHTML = '<div id="desktop"></div>';
  });
</script>

App Store

Register apps with kernel.appStore.register(meta). Apps with store: true are persisted and visible to any WebOS running the same kernel version.

WebOSKernel.onReady(kernel => {
  kernel.appStore.register({
    id:            'com.example.notes',
    name:          'Notes',
    version:       '1.0.0',
    kernelVersion: '1.2.0',
    store:         true,
    sourceCode:    '<h1>My Notes App</h1>',
  });
  const apps = kernel.appStore.list();
});

Cloud

Firebase connects lazily — no overhead unless you use it. loadApps() fetches the apps Firestore collection and auto-registers everything.

WebOSKernel.onReady(async kernel => {
  await kernel.cloud.loadApps();
  const data = await kernel.cloud.fetch('settings');
  const app  = await kernel.cloud.getApp('com.example.notes');
});

Launching apps

kernel.launch(appId) checks the local AppStore, falls back to Firebase, builds a sandboxed iframe, and returns it ready to place in your OS UI.

WebOSKernel.onReady(async kernel => {
  const iframe = await kernel.launch('com.example.notes');
  document.getElementById('window-container').appendChild(iframe);
  kernel.events.on('app:ready', ({ name }) => {
    console.log(name, 'is live');
  });
});

Events

API reference

kernel-sms.js
Messaging kernel.

Trimmed for conversation-driven WebOSes. No AppStore, no launch(). Adds cloud.send() for writing messages to Firestore and cloud.subscribe() for real-time updates.

Getting started

<script src="https://webnux.pages.dev/kernel-sms.js"></script>
<script>
  WebOSKernel.onReady(kernel => {
    // your messaging OS starts here
  });
</script>

Sending messages

kernel.cloud.send(collection, message) writes to Firestore with a server timestamp. Returns the new document ID.

const id = await kernel.cloud.send('messages', {
  from: 'alice', text: 'Hello!', channel: 'general',
});

Real-time updates

kernel.cloud.subscribe(collection, cb) opens a Firestore onSnapshot listener. Returns an unsubscribe function.

const unsub = await kernel.cloud.subscribe('messages', messages => {
  renderMessages(messages);
});
// call unsub() to stop listening

API reference

kernel-tools.js
Headless kernel.

No UI, no boot screen, no app launching. Boots instantly and registers four built-in tool services: dev:console, dev:inspector, util:calc, and util:notes.

Getting started

<script src="https://webnux.pages.dev/kernel-tools.js"></script>
<script>
  WebOSKernel.onReady(kernel => {
    const con = kernel.resolve('dev:console');
    const cal = kernel.resolve('util:calc');
  });
</script>

dev:console

Intercepts console.log/warn/error/info/debug from the moment the kernel loads. Build a visible log panel in your UI.

con.history();         // all captured entries
con.tail(50);          // last 50 entries
con.filter('error');   // only errors
con.clear();           // wipe history

dev:inspector

Dumps a snapshot of kernel state — uptime, services, plugins, routes, heap memory.

const snap = ins.snapshot();  // { version, mode, uptime, services, memoryMB, … }
ins.print();                  // logs formatted snapshot to console

util:calc

Safe math expression evaluator. No arbitrary code execution — strips anything non-numeric before evaluating.

cal.evaluate('2 + 2');          // 4
cal.evaluate('(10 * 3) / 2');  // 15
cal.evaluate('100 % 7');        // 2

util:notes

In-memory key/value note store. Session-only — wire your own persistence if needed.

nts.set('todo', 'Fix the kernel');
nts.get('todo');                  // { id, content, updatedAt }
nts.list();                       // all notes
nts.search('kernel');             // notes matching substring
nts.delete('todo');

Auth kernels.
Login-gated WebOS.

Modes 4 and 5 are identical to Modes 1 and 2 — same API, same events — with one addition: the kernel holds the boot sequence behind a login screen until the user authenticates via Firebase Auth. onReady() only fires after a successful sign-in.

WebOSKernel.onReady(async kernel => {
  // user is guaranteed to be signed in here
  console.log(kernel.auth.currentUser.email);
  await kernel.auth.signOut();  // returns to login on next load
});

WebNux
The unified kernel namespace.

kernel-os.js exposes a second global — WebNux — that wraps every subsystem into a clean, namespaced API. Both globals point at the same kernel instance.

WebNux.onReady(nx => {
  console.log(nx.version);      // '1.2.0'
  console.log(nx.history);      // ['Web Kernel', 'WebNix', 'WebNux']
  console.log(nx.manifest());   // full boot report
});

WebNux.mm — Memory

Physical memory manager (buddy allocator), SLUB allocator, and virtual memory maps. Page size: 4 KiB. Orders follow the buddy system (order 0 = 4 KiB, order 9 = 2 MiB huge page).

WebNux.proc — Processes

Spawn tasks, fork processes, create threads, run ELF or JS-native executables. Each task gets a PID, memory map, and capability set.

WebNux.net — Networking

BSD socket API over simulated IPv4 / TCP / UDP. Loopback delivery works — packets sent to a local port land in the peer socket's receive queue.

WebNux.ipc — IPC

SysV message queues, semaphores, shared memory, and kernel ring-buffer pipes.

WebNux.sec — Security

Linux capability model (41 caps), user/group database, SENux MAC, and seccomp.

WebNux.power — Power & CPU

ACPI power states and CPU frequency scaling. ACPI is wired to the browser's Page Visibility API — automatically emits S3 on tab switch and S0 on return.

WebNux.mod — Kernel Modules

Load and unload kernel modules at runtime. A module is a plain JS object with name, init(kernel), and optionally exit(kernel).

const myMod = {
  name: 'hello_world', version: '1.0.0', license: 'GPL',
  init(k) { k.events.emit('hello:loaded', {}); },
  exit(k) { console.log('unloaded'); },
};
nx.mod.insmod(myMod);          // load
nx.mod.lsmod();               // list all
nx.mod.rmmod('hello_world');  // unload

WebNux.fs — Filesystem

Access the live /proc virtual filesystem, block devices, VFS, and OPFS persistent storage.