← Back to Downloads

DBBasic Suite File Formats

Version: 1.0.0 Last Updated: November 2, 2025

Overview

DBBasic Suite uses HTML as its native file format for all three applications. This is not a limitation—it's a feature. HTML provides unparalleled portability, longevity, and accessibility.

Why HTML?

Future-Proof

HTML has existed since 1991 and will be readable for decades. Your documents won't become obsolete when software changes.

Universal Compatibility

Human-Readable

Unlike proprietary formats (.docx, .xlsx), you can: - Open files in a text editor and read the content - Use grep/search to find text across thousands of documents - Version control with git - Parse with simple scripts

No Vendor Lock-In

DBBasic Writer File Format

Extension

.html

Structure

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document Title</title>
    <style>
        /* Embedded CSS for formatting */
        body {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto;
            line-height: 1.6;
            max-width: 8.5in;
            margin: 40px auto;
            padding: 40px;
        }
        /* Additional styles... */
    </style>
</head>
<body>
    <div class="editor" contenteditable="true">
        <!-- Document content with inline formatting -->
        <h1>Your heading</h1>
        <p>Your paragraph text with <strong>bold</strong> and <em>italic</em>.</p>
    </div>
</body>
</html>

What's Stored

Viewing/Editing

Templates Included

DBBasic Writer includes these templates (also HTML files): - term-paper.html - Academic paper with bibliography - resume.html - Professional resume - business-letter.html - Formal business letter - report.html - Technical report with sections

DBBasic Spreadsheet File Format

Extension

.html

Structure

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Spreadsheet - DBBasic Sheets</title>
    <style>
        /* Table styling */
        .spreadsheet {
            border-collapse: collapse;
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI";
        }
        td[data-cell] {
            border: 1px solid #ddd;
            padding: 8px;
            min-width: 80px;
        }
        /* Additional styles... */
    </style>
    <script type="application/json" id="dbbasic-spreadsheet-data">
    {
      "A1": {"value": "42", "type": "number"},
      "A2": {"value": "100", "type": "number"},
      "A3": {"value": "142", "type": "number", "formula": "=SUM(A1:A2)"}
    }
    </script>
</head>
<body>
    <div class="spreadsheet-container">
        <table class="spreadsheet">
            <tr>
                <th></th><th>A</th><th>B</th><th>C</th>
            </tr>
            <tr>
                <th>1</th>
                <td data-cell="A1" data-value="42" data-type="number">42</td>
                <td data-cell="B1"></td>
                <td data-cell="C1"></td>
            </tr>
            <!-- More rows... -->
        </table>
    </div>
    <script src="embedded.js"></script>
</body>
</html>

What's Stored

Supported Formulas (v1.0)

Viewing/Editing

Data Portability

The embedded JSON format makes it easy to: - Extract data programmatically - Import into databases - Convert to CSV/TSV - Process with Python/JavaScript

DBBasic Slides File Format

Extension

.html

Structure

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Presentation - DBBasic Slides</title>
    <style>
        /* Presentation styling */
        .slide {
            width: 960px;
            height: 720px;
            padding: 40px;
            box-sizing: border-box;
            background: white;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
        }
        .slide h1 {
            font-size: 3em;
            text-align: center;
        }
        /* Additional styles... */
    </style>
</head>
<body>
    <div class="slides">
        <div class="slide" data-slide="1">
            <h1 contenteditable="true">Title Slide</h1>
            <p contenteditable="true">Subtitle text</p>
        </div>
        <div class="slide" data-slide="2">
            <h2 contenteditable="true">Second Slide</h2>
            <p contenteditable="true">Content here</p>
        </div>
        <!-- More slides... -->
    </div>
    <script src="slides.js"></script>
</body>
</html>

What's Stored

Viewing/Presenting

Presentation Controls (in browser)

File Interoperability

Importing to DBBasic Suite

From Microsoft Office: - Word → Save as HTML → Open in DBBasic Writer ✅ - Excel → Save as HTML → Open in DBBasic Spreadsheet ⚠️ (formulas may need adjustment) - PowerPoint → No direct path ❌ (copy/paste content)

From Google Docs: - Docs → File → Download → Web Page (.html) → Open in DBBasic Writer ✅ - Sheets → File → Download → Web Page (.html) → Open in DBBasic Spreadsheet ⚠️ - Slides → No direct path ❌ (copy/paste content)

From Other Sources: - Plain text → Copy/paste into any DBBasic app ✅ - CSV data → Import into Spreadsheet (manual paste) ✅ - Markdown → Convert to HTML → Open in Writer ✅

Exporting from DBBasic Suite

To PDF: - All apps → Print → Save as PDF ✅

To Microsoft Office: - Writer → Open HTML in Word → Save as .docx ✅ - Spreadsheet → Copy/paste into Excel ⚠️ - Slides → Copy/paste into PowerPoint ⚠️

To Plain Text: - Open in browser → Select all → Copy → Paste ✅

To Other Formats: - Use browser's "Save As" for various formats - Use pandoc to convert HTML to many formats - Parse HTML with any programming language

Working with DBBasic Files Programmatically

Reading Data

Python example (Spreadsheet):

from bs4 import BeautifulSoup
import json

with open('spreadsheet.html', 'r') as f:
    html = f.read()

soup = BeautifulSoup(html, 'html.parser')
data_script = soup.find('script', {'id': 'dbbasic-spreadsheet-data'})
data = json.loads(data_script.string)

print(data['A1']['value'])  # Access cell values

JavaScript example (Writer):

const fs = require('fs');
const jsdom = require('jsdom');

const html = fs.readFileSync('document.html', 'utf8');
const dom = new jsdom.JSDOM(html);
const content = dom.window.document.querySelector('.editor').textContent;

console.log(content);

Generating Files

Create a Writer document:

template = """<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{title}</title>
    <style>/* styles here */</style>
</head>
<body>
    <div class="editor">{content}</div>
</body>
</html>"""

doc = template.format(
    title="My Report",
    content="<h1>Report Title</h1><p>Content here</p>"
)

with open('report.html', 'w') as f:
    f.write(doc)

AI Integration: The Native Advantage

Why HTML is Perfect for AI

In 2025, AI assistants like Claude, ChatGPT, and local LLMs are everywhere. DBBasic's HTML format gives you a massive advantage: AI can read and write your documents directly without any special libraries.

Other formats need special libraries:

# .docx requires python-docx (complex API)
from docx import Document
doc = Document()
doc.add_paragraph("Hello")
doc.save("file.docx")  # Binary blob

# .xlsx requires openpyxl (complex API)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws['A1'] = "Hello"
wb.save("file.xlsx")  # Binary blob

# .pptx requires python-pptx (complex API)
from pptx import Presentation
prs = Presentation()
slide = prs.slides.add_slide(prs.slide_layouts[0])
prs.save("file.pptx")  # Binary blob

DBBasic formats just write HTML:

# Writer document - AI writes HTML directly
html = """<!DOCTYPE html>
<html><head><title>Report</title></head>
<body><h1>Quarterly Report</h1><p>Sales increased 25%...</p></body>
</html>"""
with open("report.html", "w") as f:
    f.write(html)  # Done. Human-readable.

# Spreadsheet - AI writes HTML table + JSON
# Slides - AI writes HTML divs

Real-World AI Use Cases

1. Generate Documents from Data

You: "Claude, analyze these sales numbers and create a report"
AI: Reads CSV → Writes Writer HTML with analysis → Done

2. Batch Document Generation

You: "Create 50 personalized sales letters from this template"
AI: Reads template.html → Generates 50 variations → Saves 50 .html files

3. Spreadsheet Automation

You: "Create expense spreadsheets for each department with 2024 tax rates"
AI: Generates DBBasic Spreadsheet HTML with formulas → Done

4. Presentation Creation

You: "Turn these meeting notes into a 10-slide presentation"
AI: Reads notes → Generates Slides HTML with formatted content → Done

5. Document Analysis

You: "Summarize all quarterly reports from 2024"
AI: Reads .html files directly (no parsing libraries) → Analyzes → Summarizes

6. Content Transformation

You: "Convert this spreadsheet data into a formatted report"
AI: Reads Spreadsheet HTML/JSON → Generates Writer HTML → Done

Why This Matters

No Special Libraries Needed - AI models are trained on HTML (billions of examples) - No need to learn python-docx, openpyxl, python-pptx APIs - Works with any AI (local LLMs, cloud APIs, etc.)

Direct Read/Write - AI can cat file.html and understand it immediately - AI can write valid HTML from its training - No binary parsing, no XML hell, no proprietary schemas

Human + AI Collaboration - You start a document → AI completes it - AI generates draft → You edit in DBBasic Writer - Back and forth seamlessly

Automation at Scale - Process thousands of documents with AI - No license costs for automation libraries - Simple Python/JavaScript scripts

Comparison: Creating 100 Reports

With .docx (proprietary):

from docx import Document  # Requires library install
import docx.shared  # Complex API to learn

for i in range(100):
    doc = Document()
    # 20+ lines of docx API calls to format properly
    doc.add_heading(f"Report {i}", level=1)
    # More complex formatting...
    doc.save(f"report_{i}.docx")

With DBBasic Writer (HTML):

template = open("template.html").read()  # No special library

for i in range(100):
    report = template.replace("{number}", str(i))
    # AI can modify HTML directly - it's just text
    with open(f"report_{i}.html", "w") as f:
        f.write(report)

The AI-Native Office Suite

DBBasic Suite is the first AI-native office suite:

In the AI era, your documents should be AI-readable by default.

DBBasic files are.

Version Control with Git

DBBasic files work perfectly with version control:

# Initialize git repo for your documents
cd ~/Documents
git init
git add *.html
git commit -m "Initial document versions"

# Make changes in DBBasic apps, then:
git diff document.html  # See what changed
git commit -am "Updated introduction section"

# Collaborate
git push origin main

Benefits

File Size Comparison

Application Empty File Typical Document Large Document
DBBasic Writer 2 KB 10-50 KB 200 KB
Microsoft Word 25 KB 50-500 KB 5 MB+
DBBasic Spreadsheet 3 KB 20-100 KB 500 KB
Microsoft Excel 30 KB 100-1000 KB 10 MB+
DBBasic Slides 3 KB 15-80 KB 300 KB
Microsoft PowerPoint 40 KB 500 KB-5 MB 50 MB+

Why DBBasic files are smaller: - Plain text HTML (no binary bloat) - No embedded XML packaging - No hidden metadata - No compatibility layers

File Longevity

DBBasic HTML Files (1995 → Today)

HTML from 1995 still opens in modern browsers. Your DBBasic files will be readable in 2050.

Microsoft Office Formats

Guarantee

HTML is an open standard maintained by W3C and WHATWG. It's not going anywhere. Your files will outlive any proprietary format.

Security Considerations

What's Safe

What to Watch For

Best Practices

FAQ

Can I edit DBBasic files in other software?

Yes. You can open them in: - Any text editor (VS Code, Sublime, vim, Notepad++) - Any web browser - Microsoft Word/Excel (as HTML) - Many other programs

Will my files work if DBBasic goes away?

Yes. Files are standard HTML. They'll work forever, even if DBBasic Suite stops existing.

Can I batch process DBBasic files?

Yes. Use any programming language (Python, JavaScript, Ruby, etc.) to: - Extract text - Convert formats - Analyze data - Generate reports

Are DBBasic files searchable by macOS Spotlight?

Yes. HTML text content is indexed and searchable.

Can I email DBBasic files?

Yes. They're just HTML files. Email them like any other attachment. Recipients can open them in a browser even without DBBasic Suite.

Do DBBasic files work offline?

Yes. Files are completely self-contained. No internet required.

Can I print DBBasic files without the apps?

Yes. Open in any browser and print.

Technical Specifications

Character Encoding

UTF-8 (supports all languages and emoji)

Line Endings

Unix-style (LF) for better git compatibility

HTML Version

HTML5 (latest web standard)

CSS Level

CSS3 (modern styling)

JavaScript

Not required for viewing; only used in apps for interactivity

Maximum File Size

Limited only by your disk space (tested up to 100 MB)

Maximum Cells (Spreadsheet)

26 columns (A-Z) × 100 rows = 2,600 cells (v1.0)

Maximum Slides (Slides)

Unlimited (tested up to 200 slides)

Roadmap

Future Format Enhancements

v1.1: - Image embedding (base64 data URLs) - More spreadsheet columns (AA, AB, etc.) - Slide templates

v2.0: - Tables in Writer - Charts in Spreadsheet - Animations in Slides - Collaborative editing metadata

All future versions will maintain backward compatibility with v1.0 files.

Support

Questions about file formats? - Email: dan@quellhorst.com - Website: https://dbbasic.com

Copyright © 2025 DBBasic. All rights reserved.