.RSL

Task 622: .RSL File Format

thinkmelt@protonmail.com

Nov 16, 2025 • 6 min read

1. Properties of the .RSL File Format

The .RSL file format is an XML-based standard for Really Simple Licensing (RSL), designed to define machine-readable licensing terms for digital assets, including permissions, restrictions, payment models, and metadata. The format conforms to XML 1.0 and uses the namespace "https://rslstandard.org/rsl". Below is a comprehensive list of all intrinsic properties (elements and attributes) of the format, including their requirements, data types, and descriptions, based on the RSL Version 1.0 Draft specification.

Root Element:

Attributes:
xmlns (String, Required): Namespace URI ("https://rslstandard.org/rsl").
Description: Encloses all content and license definitions.

Element:

Attributes:
url (String, Required): Location of the asset, supporting wildcards (*, $).
server (String, Optional): URL of the license server.
encrypted (Boolean, Optional): Indicates encryption status (true/false, default: false).
lastmod (DateTime, Optional): Last modification date (RFC 3339 format).
Description: Defines a digital asset and its licensing details.

Element:

No attributes.
Description: Specifies rights, costs, and restrictions for an asset.

Element:

Attributes:
type (String, Required): One of "usage", "user", or "geo".
Description: Defines allowed uses; content is comma-separated values specific to the type (e.g., "ai-train,search" for usage).

Element:

Attributes:
type (String, Required): One of "usage", "user", or "geo".
Description: Defines prohibited uses; content is comma-separated values specific to the type.

Element:

Attributes:
type (String, Optional): One of "purchase", "subscription", "training", "crawl", "inference", "attribution", or "free" (default: free).
Description: Defines compensation model.

Element:

No attributes.
Description: URL to a standard licensing agreement (content is the URL).

Element:

No attributes.
Description: URL to a custom licensing agreement (content is the URL).

Element:

Attributes:
currency (String, Required): ISO 4217 code (e.g., "USD").
Description: License cost; content is a decimal number.

Element:

Attributes:
type (String, Required): "warranty" or "disclaimer".
Description: Legal statements; content is comma-separated values specific to the type (e.g., "ownership,no-infringement" for warranty).

Element:

No attributes.
Description: URL to Schema.org metadata (content is the URL).

Element:

Attributes:
type (String, Optional): "person" or "organization".
contactEmail (String, Optional): Email for inquiries.
contactUrl (String, Optional): URL for contact.
Description: Identifies the rights holder.

Element:

No attributes.
Description: URL to additional legal terms (content is the URL).

These properties ensure the format is structured for machine-readable processing while supporting compliance with standards such as Robots Exclusion Protocol, ISO codes, and Schema.org.

2. Direct Download Links for .RSL Files

Extensive searches did not yield direct download links for .RSL files conforming to the Really Simple Licensing format, as it is a relatively new standard with examples primarily embedded in documentation rather than as standalone downloadable files. However, the following pages provide XML examples that can be saved as .RSL files:

https://rslstandard.org/guide/license-servers (contains an embeddable XML example).
https://rslcollective.org/encrypted-content (contains an embeddable XML example).

3. Ghost Blog Embedded HTML JavaScript for .RSL File Drag-and-Drop

The following is an HTML page with embedded JavaScript that can be embedded in a Ghost blog post. It allows users to drag and drop a .RSL file, parses the XML, and displays all properties (elements, attributes, and content) in a structured list on the screen.

RSL File Parser

Drag and drop a .RSL file here

4. Python Class for .RSL Files

The following Python class can open, decode (parse), read, write, and print all properties from a .RSL file using the xml.etree.ElementTree module.

import xml.etree.ElementTree as ET
import os

class RSLFileHandler:
    def __init__(self, filename):
        self.filename = filename
        self.tree = None
        self.root = None

    def open_and_read(self):
        if not os.path.exists(self.filename):
            raise FileNotFoundError(f"File {self.filename} not found.")
        self.tree = ET.parse(self.filename)
        self.root = self.tree.getroot()

    def print_properties(self):
        if self.root is None:
            raise ValueError("File not opened or parsed.")
        def traverse(node, level=0):
            indent = '  ' * level
            print(f"{indent}Element: {node.tag}")
            for attr, value in node.attrib.items():
                print(f"{indent}  Attribute: {attr} = {value}")
            if node.text and node.text.strip():
                print(f"{indent}  Content: {node.text.strip()}")
            for child in node:
                traverse(child, level + 1)
        traverse(self.root)

    def write(self, new_filename=None):
        if self.tree is None:
            raise ValueError("No data to write.")
        filename = new_filename or self.filename
        self.tree.write(filename, encoding='utf-8', xml_declaration=True)

# Example usage:
# handler = RSLFileHandler('example.rsl')
# handler.open_and_read()
# handler.print_properties()
# handler.write('output.rsl')

5. Java Class for .RSL Files

The following Java class can open, decode (parse), read, write, and print all properties from a .RSL file using javax.xml.parsers.DocumentBuilder.

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;

public class RSLFileHandler {
    private String filename;
    private Document doc;

    public RSLFileHandler(String filename) {
        this.filename = filename;
    }

    public void openAndRead() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        doc = builder.parse(new File(filename));
    }

    public void printProperties() {
        if (doc == null) {
            throw new IllegalStateException("File not opened or parsed.");
        }
        traverse(doc.getDocumentElement(), 0);
    }

    private void traverse(Node node, int level) {
        String indent = "  ".repeat(level);
        System.out.println(indent + "Element: " + node.getNodeName());
        NamedNodeMap attrs = node.getAttributes();
        if (attrs != null) {
            for (int i = 0; i < attrs.getLength(); i++) {
                Node attr = attrs.item(i);
                System.out.println(indent + "  Attribute: " + attr.getNodeName() + " = " + attr.getNodeValue());
            }
        }
        String text = node.getTextContent();
        if (text != null && !text.trim().isEmpty()) {
            System.out.println(indent + "  Content: " + text.trim());
        }
        NodeList children = node.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node child = children.item(i);
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                traverse(child, level + 1);
            }
        }
    }

    public void write(String newFilename) throws Exception {
        if (doc == null) {
            throw new IllegalStateException("No data to write.");
        }
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        DOMSource source = new DOMSource(doc);
        StreamResult result = new StreamResult(new File(newFilename != null ? newFilename : filename));
        transformer.transform(source, result);
    }

    // Example usage:
    // public static void main(String[] args) throws Exception {
    //     RSLFileHandler handler = new RSLFileHandler("example.rsl");
    //     handler.openAndRead();
    //     handler.printProperties();
    //     handler.write("output.rsl");
    // }
}

6. JavaScript Class for .RSL Files

The following JavaScript class can open (using FileReader), decode (parse), read, write (using Blob), and print all properties from a .RSL file. It is suitable for browser environments.

class RSLFileHandler {
  constructor() {
    this.xmlDoc = null;
  }

  openAndRead(file) {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.onload = (event) => {
        try {
          const parser = new DOMParser();
          this.xmlDoc = parser.parseFromString(event.target.result, 'application/xml');
          if (this.xmlDoc.getElementsByTagName('parsererror').length > 0) {
            throw new Error('Invalid XML');
          }
          resolve();
        } catch (error) {
          reject(error);
        }
      };
      reader.readAsText(file);
    });
  }

  printProperties() {
    if (!this.xmlDoc) {
      throw new Error('File not opened or parsed.');
    }
    const traverse = (node, level = 0) => {
      const indent = '  '.repeat(level);
      let output = `${indent}Element: ${node.tagName}\n`;
      for (let i = 0; i < node.attributes.length; i++) {
        const attr = node.attributes[i];
        output += `${indent}  Attribute: ${attr.name} = ${attr.value}\n`;
      }
      if (node.textContent.trim()) {
        output += `${indent}  Content: ${node.textContent.trim()}\n`;
      }
      console.log(output);
      for (let child of node.children) {
        traverse(child, level + 1);
      }
    };
    traverse(this.xmlDoc.documentElement);
  }

  write(filename) {
    if (!this.xmlDoc) {
      throw new Error('No data to write.');
    }
    const serializer = new XMLSerializer();
    const xmlStr = serializer.serializeToString(this.xmlDoc);
    const blob = new Blob([xmlStr], { type: 'application/xml' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = filename || 'output.rsl';
    a.click();
    URL.revokeObjectURL(url);
  }
}

// Example usage:
// const handler = new RSLFileHandler();
// const input = document.createElement('input');
// input.type = 'file';
// input.onchange = async (e) => {
//   await handler.openAndRead(e.target.files[0]);
//   handler.printProperties();
//   handler.write('output.rsl');
// };
// document.body.appendChild(input);

7. C++ Class for .RSL Files

The following C++ class can open, decode (parse using tinyxml2, assuming it is available or included as a dependency), read, write, and print all properties from a .RSL file. Note that C does not have native classes, so C++ is used for this implementation.

#include <iostream>
#include <fstream>
#include <string>
#include "tinyxml2.h" // Assume tinyxml2 library is included for XML parsing

using namespace tinyxml2;

class RSLFileHandler {
private:
    std::string filename;
    XMLDocument doc;

public:
    RSLFileHandler(const std::string& fn) : filename(fn) {}

    void openAndRead() {
        XMLError error = doc.LoadFile(filename.c_str());
        if (error != XML_SUCCESS) {
            throw std::runtime_error("Failed to load file.");
        }
    }

    void printProperties() {
        if (doc.RootElement() == nullptr) {
            throw std::runtime_error("File not opened or parsed.");
        }
        traverse(doc.RootElement(), 0);
    }

    void traverse(XMLElement* node, int level) {
        std::string indent(level * 2, ' ');
        std::cout << indent << "Element: " << node->Name() << std::endl;
        for (const XMLAttribute* attr = node->FirstAttribute(); attr; attr = attr->Next()) {
            std::cout << indent << "  Attribute: " << attr->Name() << " = " << attr->Value() << std::endl;
        }
        const char* text = node->GetText();
        if (text && std::string(text).find_first_not_of(" \t\n\r") != std::string::npos) {
            std::cout << indent << "  Content: " << text << std::endl;
        }
        for (XMLElement* child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
            traverse(child, level + 1);
        }
    }

    void write(const std::string& newFilename) {
        if (doc.RootElement() == nullptr) {
            throw std::runtime_error("No data to write.");
        }
        doc.SaveFile((newFilename.empty() ? filename : newFilename).c_str());
    }
};

// Example usage:
// int main() {
//     try {
//         RSLFileHandler handler("example.rsl");
//         handler.openAndRead();
//         handler.printProperties();
//         handler.write("output.rsl");
//     } catch (const std::exception& e) {
//         std::cerr << "Error: " << e.what() << std::endl;
//     }
//     return 0;
// }