.rel
Native Application Files

The signed, manifest-driven file format for RAVADY OS apps, tools, and runtime units. Package code, assets, permissions, and recovery metadata in one first-class system artifact.

Learn More View Examples 
@metadata:
name: Local Catalog
version: 1.0.0
entry: LocalCatalog.rel
runtime: relscript

@permissions:
Allow using the native window surface.
Allow reading "apps/".
Allow writing "data/".

@logic:
Catalog local applications into the verified local catalog.
Present the catalog workspace using the declared screen and style.
Do not fetch or install a package until its signed envelope, publisher key, and revocation status are verified.

@screen:
A header bar with the title "Local Catalog"
A search row with a text field labeled "Search verified apps"
A row of buttons
  **Discover** **Updates** **Sources** **Developer**

@style:
Background is midnight (#0A0F19)
Text is cloud white (#F6FAFF)
@end

Overview

What is .rel?

.rel files are the native application format for RAVADY OS. They provide a single artifact that declares identity, entrypoints, permissions, assets, and lifecycle metadata so the launcher and runtime manager can install, verify, and run apps predictably.

Signed Manifest

Describe the app's identity, entrypoint, permissions, and trust material in one place.

Multi-Language Support

Bundle runtime code, UI assets, and supporting resources into a contained application unit.

Key Benefits

Reliable Delivery

Bundle code, UI assets, and metadata into one versioned artifact the system can verify and install consistently.

Runtime Control

Declared permissions and entrypoints let the launcher and runtime enforce policy before code runs.

Security

Works with sandboxing, trust checks, and recovery workflows. Per-app resource limits are on the roadmap.

File Format

Structure

A Ravady .rel file is a unified single-file application format combining YAML frontmatter (manifest & capability declarations), script logic (<script> in English CNL, Lua, JS, or Python), reactive HTML markup with {expression} templating and control flow, and scoped CSS: 

---
name: Notes
version: 1.0.0
permissions:
  filesystem: [data/notes/]
  clipboard: true
---
<script lang="lua">
local notes = { "Buy milk", "Review PR" }
function add_note(text) table.insert(notes, text) end
</script>

<div class="notes-app">
  <h1>Quick Notes</h1>
  <ul>
    {#each notes as note, i}
      <li>{i}: {note}</li>
    {:else}
      <li class="empty">No notes yet</li>
    {/each}
  </ul>
</div>

<style>
.notes-app { font-family: 'Exo 2', sans-serif; color: #fff; }
.empty { color: #64748b; font-style: italic; }
</style>

Manifest (Frontmatter)

The inline frontmatter between --- delimiters declares the application's identity, version, and capability grants.

Required Fields

  • name - Application name
  • version - Semantic version string
  • permissions - Capability grants (filesystem paths, network endpoints)

Optional Fields

  • author - Developer name
  • description - Brief application summary
  • entry - Optional entry point (defaults to self)
  • runtime - Execution profile (e.g. lua, js, python)

Component Composition

Modular apps compose sub-components with <include src="..." />. Included components run in the same execution scope and inherit the parent's manifest security envelope: 

<div class="dashboard">
  <include src="/components/header.rel" />
  <main>
    <include src="/components/sidebar.rel" />
    <section class="main-content">
      <h2>{page_title}</h2>
    </section>
  </main>
</div>
}

Runtime Lifecycle

Runtime Manager

The runtime manager validates the manifest, mounts packaged resources, resolves the requested runtime, and launches the app inside Ravady's policy boundary. 

class RuntimeManager {
launch(bundlePath) {
const bundle = this.readBundle(bundlePath);
this.verifySignature(bundle.manifest);
this.enforcePermissions(bundle.manifest.permissions);
const runtime = this.resolveRuntime(bundle.manifest.entry);

return runtime.start(bundle.files, bundle.manifest);
}
}

Execution Process

  1. 1.
    Manifest Validation: Identify .rel bundle and parse manifest
  2. 2.
    Trust Check: Verify signatures, checksums, and source policy
  3. 3.
    Permission Binding: Grant the declared capabilities and resource limits
  4. 4.
    Resource Mount: Load packaged files, assets, and runtime dependencies
  5. 5.
    App Launch: Start the selected runtime and surface inside the launcher sandbox

Platform Support

A flexible foundation. Ravady is designed to bring the same clear application experience to a range of computers as the platform grows.

Windows

Not a current target

Linux

Not a hosted target; POSIX support is selective

Android

Not a current target

Web

Not a current target

Examples

Basic Application (Interactive Counter)

---
name: Counter
version: 1.0.0
permissions:
  filesystem: [data/]
---
<script lang="lua">
count = 0
function increment() count = count + 1 end
</script>

<div class="counter-card">
  <h2>Current Count: {count}</h2>
  {#if count == 0}
    <p>Click below to start counting</p>
  {:else if count > 10}
    <p class="milestone">Double digits reached!</p>
  {/if}
  <button on:click={increment}>Increment</button>
</div>

<style>
.counter-card { padding: 2rem; border-radius: 12px; background: rgba(15, 23, 42, 0.9); }
.milestone { color: #00ff8f; font-weight: bold; }
</style>

Component Composition

---
name: AppShell
version: 1.0.0
permissions:
  filesystem: [data/]
  network: [api.ravady.com]
---
<script lang="lua">
app_title = "Studio Dashboard"
</script>

<div class="layout">
  <include src="/components/header.rel" />
  <div class="body-row">
    <include src="/components/sidebar.rel" />
    <main class="content">
      <h1>{app_title}</h1>
    </main>
  </div>
</div>

<style>
.layout { display: flex; flex-direction: column; height: 100vh; }
.body-row { display: flex; flex: 1; }
</style>

Python-Powered Component

---
name: DataAnalyzer
version: 1.0.0
permissions:
  filesystem: [data/analytics/]
---
<script lang="python">
def compute_stats(samples):
    total = 0
    for s in samples:
        total = total + s
    avg = total / len(samples)
    return { "total": total, "avg": avg }

metrics = compute_stats([12, 45, 68, 92, 105])
</script>

<div class="stats-panel">
  <h3>Analytics Summary</h3>
  <p>Total: {metrics.total}</p>
  <p>Average: {metrics.avg}</p>
</div>

NL RelScript (Natural-Language Authoring)

Natural-Language RelScript is the friendly authoring level for .rel apps. Instead of writing product code in a <script> block, you describe the complete app in prose sections marked with @section: headers. The rel_format QKey converter extension parses each section and maps its vocabulary to the same typed Core RelScript operations used by advanced developers. Core RelScript is the precise form; NL RelScript is its readable surface. Both use the same permissions, tests, sandbox, and native runtime. Lua is only a generated backend. Tagged Lua, JS-like, Python, and English blocks remain compatibility loaders for older apps; they are not a new product-source path.

Store is the reference NL app in the kernel VFS. Its document provides the runtime manifest, permissions, catalog behavior, and visible workspace contract; unsupported document behavior fails instead of falling back to imperative app source. 

@metadata:
name: NoteApp
version: 1.0.0
entry: NoteApp.rel
runtime: relscript

@state:
count is a number starting at 0
note_text is text starting as ""

@logic:
To increment:
increase count by 1

@events:
When the **Add** button is pressed, increment
When the **Clear** button is pressed, remember count as 0

@rules:
If count > 10: show "Many notes" Otherwise: show "Few notes"

@screen:
A header bar with the title "Notes"
A button row with **Add** and **Clear**
A text field for the note
A status bar showing the count

@style:
Background is white (#ffffff)
Text color is dark (#222222)
Font is sans-serif
Header bar is blue (#4488cc)

@end

Section reference: @metadata (inline frontmatter), @state (typed declarations), @logic / @events / @rules (CNL verbs), @screen (prose → DOM), @style (prose → CSS), @end.

API Reference

File Operations

// Read a file
const content = await readFile('data.txt', 'utf8');

// Write to a file
await writeFile('output.txt', 'Hello World!');

// List directory contents
const files = await readdir('.');
files.forEach(file => print(file));

// Check if file exists
const exists = await fileExists('config.json');

// Get file information
const stats = await stat('document.pdf');
print(\`Size: \${stats.size} bytes\`);

System API

// Get system information
const os = getOS(); // 'windows', 'linux', 'android', 'web'
const arch = getArchitecture(); // 'x64', 'arm64', etc.
const version = getOSVersion();

// Environment variables
const homeDir = getEnv('HOME') || getEnv('USERPROFILE');
const tempDir = getTempDirectory();

// Execute system command
const result = await executeCommand('ls -la');

// Get current working directory
const cwd = getCurrentDirectory();

// Change directory
changeDirectory('/home/user/documents');

Network API

// HTTP GET request
const response = await fetch('https://api.example.com/data');
const data = await response.json();

// HTTP POST request
const postResponse = await fetch('https://api.example.com/submit', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name: 'John', age: 30 })
});

// WebSocket connection
const ws = new WebSocket('ws://localhost:8080');
ws.onMessage = (message) => {
print('Received:', message);
};
ws.send('Hello Server!');

// DNS resolution
const ip = await resolveDNS('example.com');

// Get network interfaces
const interfaces = getNetworkInterfaces();
interfaces.forEach(iface => {
print(\`\${iface.name}: \${iface.address}\`);
});