# Craft++ vs BYOND Dream Maker: Comprehensive Comparison

## Executive Summary

**Craft++** is an **intentional DM-inspired language** that modernizes BYOND's Dream Maker with a clean architecture and VS Code-like IDE UI. It's **not a binary-compatible port**, but rather a fresh implementation that captures DM's essence while adding modern OOP features and fixing historical quirks. This document details the language, runtime, and IDE architectural differences.

---

## Part 1: Language Comparison (Craft++ vs DM)

### 1.1 Core Language Philosophy

| Aspect | BYOND DM | Craft++ |
|--------|----------|---------|
| **Design Era** | 1994–present (legacy syntax with modern extensions) | 2020s (clean slate, modern sensibilities) |
| **Compilation Target** | Native `.dmb` bytecode (binary blob, proprietary VM) | AST-based tree-walking interpreter (source + metadata in ZIP) |
| **Type System** | Weakly typed, optional type paths, loose coercion | Strongly typed paths, explicit `var/type/path` declarations, no silent coercion |
| **Indentation** | Indentation **or** braces (first file defines style) | Indentation **and** braces (auto-converted) |
| **Preprocessor** | Full macro support (`#define`, `#undef`, function macros) | `#define`, `#undef`, `#include` (no function macros yet) |
| **OOP Model** | Inheritance via slash paths; `..()` for parent calls | Class hierarchy with explicit inheritance; `..()` parent calls |
| **Operator Overloading** | Limited (Dream Maker handles most) | Planned (not yet implemented) |

### 1.2 Type System

#### BYOND DM Type Declarations
```dm
var/x = 5                           // Untyped, inferred as number
var/mob/player                      // Creates typed variable
var/list/items = new/list()         // Typed list
var/datum/some_datum = new()        // Generic datum (base type)
var/turf/ground/rocky = new()       // Path-based type
```

#### Craft++ Type Declarations
```
var/x = 5                           // Type inferred from value
var/mob/player                      // Explicit type path required
var/list/items = new/list()         // List with items
var/datum/some_datum = new()        // Datum base type
var/turf/ground/rocky = new()       // Inherits from turf/ground
```

**Key Difference:** Craft++ enforces path consistency at parse time; DM allows loose typing and late binding.

### 1.3 Object Tree

#### BYOND DM
```dm
/datum
    New(x, y)                       // Constructor
        src.x = x

/mob
    var/name
    proc/Move(dir) { ... }
    var/health = 100

/mob/player
    New(name)
        ..()                        // Call parent New()
        src.name = name
```

#### Craft++
```
datum
    var/x
    var/y
    proc/New(x, y)
        this.x = x

mob : datum                         // Explicit inheritance (future syntax)
    var/name
    proc/Move(dir) { ... }
    var/health = 100

mob/player : mob
    proc/New(name)
        ..()                        // Call parent proc
        this.name = name
```

**Key Difference:** Craft++ uses slash paths for namespacing but plans explicit inheritance syntax; DM relies solely on slash paths.

### 1.4 Operators

| Feature | BYOND DM | Craft++ |
|---------|----------|---------|
| **Arithmetic** | `+ - * / %` | ✓ (same) |
| **Comparison** | `== != < > <= >=` | ✓ (same) |
| **Logical** | `&& \|\| !` | ✓ (same) |
| **Bitwise** | `& \| ^ ~ << >>` | ✓ (implemented) |
| **Type Check** | `istype(x, /path)` (builtin) | `x to /path` (operator) |
| **Type Cast** | `as() builtin` | `x as /path` (operator) |
| **Null Coalescing** | N/A | `??` (implemented) |
| **String Interpolation** | `"text [var]"` | ✓ (same) |
| **Power** | `**` | Planned |

### 1.5 Control Flow

| Feature | BYOND DM | Craft++ |
|---------|----------|---------|
| **if / else** | ✓ | ✓ |
| **while** | ✓ | ✓ |
| **do-while** | ✓ | ✓ (implemented) |
| **for** | `for(i in 1 to N)` | `for (i; i < N; i++)` (C-style) |
| **for-in** | `for (x in list)` | ✓ |
| **switch/case** | ✓ | ✓ |
| **return/break/continue** | ✓ | ✓ |
| **spawn()** | `spawn(10) { }` (threading) | `spawn(10) { }` (delayed execution via WorldScheduler) |
| **del** | `del obj` (destroy) | ✓ (same) |
| **throw/try-catch** | ✓ (modern BYOND) | ✓ (implemented) |
| **goto/labels** | ✓ | ✓ (implemented) |

### 1.6 Built-in Types

#### BYOND DM Base Types
- `null`
- `num` (floating-point)
- `text` (string)
- `list` (dynamic array / map)
- `datum` (base object)
- `mob`, `obj`, `turf`, `area` (predefined datum subtypes)
- `matrix` (transformation matrix)
- `savefile` (persistent storage)
- `icon` (sprite/image)
- `sound` (audio reference)
- `image` (visual overlay)
- `screen` (HUD element)

#### Craft++ Coverage (as of now)
- ✓ Core: `null`, `num`, `text`, `list`, `bool`
- ✓ Object hierarchy: `datum`, `mob`, `obj`, `turf`, `area`
- ✓ Advanced: `matrix`, `savefile`, `icon`, `color`
- ⚠️ Partial: `sound`, `image`, `screen` (icon/image state extraction works)
- ❌ Future: `client`, `browse()`, `HTML` rendering, `JavaScript` binding

### 1.7 Built-in Procedures

#### Common Procedures (Craft++ Implemented)

| Category | BYOND DM | Craft++ |
|----------|----------|---------|
| **Math** | `rand()`, `abs()`, `max()`, `min()`, `sin()`, `cos()`, `tan()`, `sqrt()`, `log()`, `exp()`, `floor()`, `ceil()`, `round()` | ✓ (all) |
| **String** | `length()`, `copytext()`, `findtext()`, `lowertext()`, `uppertext()`, `sorttext()` | ✓ (all) |
| **List** | `length()`, `sort()`, `list2params()`, `params2list()` | ✓ (all) |
| **Type Check** | `istype()`, `isnum()`, `istext()`, `isnull()` | ✓ (all) |
| **File I/O** | `fopen()`, `fclose()`, `fread()`, `fwrite()`, `fdel()` | ✓ (implemented) |
| **System** | `alert()`, `prompt()`, `shell()` | ✓ (UI via WPF) |
| **Timing** | `sleep()` | ✓ (via WorldScheduler) |
| **JSON** | `json_encode()`, `json_decode()` | Planned |

---

## Part 2: IDE Architecture Comparison

### 2.1 High-Level Architecture Overview

#### BYOND Dream Maker
```
┌──────────────────────────────────────────────────────────┐
│                   Dream Maker (IDE)                       │
├──────────────────┬────────────────────────────────────────┤
│  Code Editor     │  File Browser                          │
│  (native C++)    │  ├─ .dme project                       │
│                  │  ├─ .dm source files                   │
│                  │  └─ .dmm maps, .dmi icons             │
├──────────────────┴────────────────────────────────────────┤
│               Compiler (Bytecode VM)                       │
│  Lexer → Parser → Semantic Analysis → Bytecode Emitter   │
└──────────────────────────────────────────────────────────┘
         ↓ (produces .dmb binary, .rsc resources)
┌──────────────────────────────────────────────────────────┐
│         Dream Daemon (Standalone Server Runtime)         │
│  - Hosts the world                                        │
│  - Accepts network connections from Dream Seeker clients  │
│  - Executes bytecode, manages object tree                │
└──────────────────────────────────────────────────────────┘
         ↓ (network protocol)
┌──────────────────────────────────────────────────────────┐
│      Dream Seeker (Standalone Client Runtime)            │
│  - Renders world tiles, verbs, HUD                       │
│  - Network I/O with Dream Daemon                         │
└──────────────────────────────────────────────────────────┘
```

#### Craft++ Architecture
```
┌──────────────────────────────────────────────────────────┐
│          Craft++ Dream Maker (WPF IDE)                   │
├──────────┬───────────────┬──────────┬──────────────────┤
│ Editor   │ Code Tree     │ Object   │ File Browser      │
│ (Monaco) │ (parsed AST)  │ Tree     │ (.dme, .dm, etc) │
│          │               │ (runtime)│                  │
├──────────┴───────────────┴──────────┴──────────────────┤
│   Compiler (In-Process)                                  │
│  Lexer → Parser → AST → Interpreter                      │
│  (Same process, live feedback)                           │
└──────────────────────────────────────────────────────────┘
         ↓ (produces .dmb/.rsc ZIP artifacts)
┌──────────────────────────────────────────────────────────┐
│    Interpreter (In-Process Tree-Walking VM)              │
│  - Environment stack (scoped variables)                  │
│  - WorldRegistry (spatial grid, type index)              │
│  - WorldScheduler (delayed execution, async tasks)       │
│  - Object tree management (all datum instances)          │
└──────────────────────────────────────────────────────────┘
         ↓ (shared memory, no network)
┌──────────────────────────────────────────────────────────┐
│    Craft++ Dream Seeker (Embedded WPF Window)            │
│  - Direct access to interpreter state                    │
│  - Canvas-based tile rendering                          │
│  - Verb UI, stat() panels, HUD overlays                 │
│  - No network protocol (same process)                   │
└──────────────────────────────────────────────────────────┘
```

### 2.2 UI Layout Comparison

#### BYOND Dream Maker
```
┌─────────────────────────────────────────────────────────────┐
│ [File][Edit][View][Tools][Help]  [Compile] [Run] [Debug]   │
├──────────────────────────────────────────────────────────────┤
│ ┌─────────────┬────────────────────────┬──────────────────┐  │
│ │ Code Tree   │ Code Editor            │ Compiler Output  │  │
│ │ (slash      │ (syntax highlighting)  │ (error log)      │  │
│ │  paths)     │                        │                  │  │
│ │             │                        │                  │  │
│ ├─────────────┼────────────────────────┼──────────────────┤  │
│ │  File Tree  │ Object Tree / Vars     │ Properties/Debug │  │
│ │             │ (instance explorer)    │                  │  │
│ └─────────────┴────────────────────────┴──────────────────┘  │
└──────────────────────────────────────────────────────────────┘
```

#### Craft++ Dream Maker
```
┌──────────────────────────────────────────────────────────────┐
│ [File][Edit][View][Tools][Help]  [Compile] [Run] [Debug]    │
├──────────────────────────────────────────────────────────────┤
│ ┌──────────────┬─────────────────────────┬────────────────┐  │
│ │ File Tree    │ Code Editor             │ Object Tree    │  │
│ │ & Code Tree  │ (AvalonEdit, syntax     │ (real-time     │  │
│ │ (tabs)       │  highlighting, find/rep)│  instance view)│  │
│ │              │                         │                │  │
│ │              │ ┌─────────────────────┤ ├──────────────┤  │
│ │              │ │ Compiler Output     │ │ Properties   │  │
│ │              │ │ (errors/warnings)   │ │ & Inspector  │  │
│ │              │ └─────────────────────┴─┴──────────────┘  │
│ └──────────────┴─────────────────────────┴────────────────┘  │
└──────────────────────────────────────────────────────────────┘
                        ↓ [Dream Seeker]
                 ┌──────────────────────────┐
                 │  Canvas World View       │
                 │  (tiles, objects, grid)  │
                 │  Verbs, Stats, HUD       │
                 └──────────────────────────┘
```

### 2.3 Editor Features Comparison

| Feature | Dream Maker | Craft++ |
|---------|-------------|---------|
| **Syntax Highlighting** | Yes (native) | Yes (AvalonEdit with custom XSHD) |
| **IntelliSense** | Yes (context-aware) | Partial (DmCompletionProvider) |
| **Go to Definition** | Yes | Yes (semantic search) |
| **Find/Replace** | Yes | Yes (AvalonEdit native) |
| **Project Management** | `.dme` + file tree | `.dme` + file/code tree hybrid |
| **Preprocessor Directives** | Visual hints | Parsed into token stream |
| **Live Syntax Check** | Background scan | DmLiveAnalyzer (real-time) |
| **Indentation → Braces** | User chooses | Automatic conversion |
| **Breakpoints** | Yes (debugger) | DebuggerService (planned) |
| **Watch Variables** | Yes | ObjectTree + PropertyInspector |
| **Call Stack Trace** | Yes | Via Exception stack |

### 2.4 File Organization Comparison

#### BYOND Dream Maker
```
project.dme                    // Master project file
    #include "map.dmm"
    #include "data/types.dm"
    #include "data/mobs.dm"
data/
    types.dm
    mobs.dm
    objs.dm
maps/
    main.dmm
icons/
    mob.dmi
    obj.dmi
```

#### Craft++
```
project.dme                    // Master project file
    #include "map.dmm"
    #include "data/types.dm"
    #include "data/mobs.dm"
data/
    types.dm                   // Parsed into Code Tree
    mobs.dm                    // Shown with hierarchy view
    objs.dm
maps/
    main.dmm                   // Map Editor preview
icons/
    mob.dmi                    // Icon Editor + state extraction
    obj.dmi
```

**IDE Pane Structure:**
- **File Tree** (left): Mirrors disk structure
- **Code Tree** (left tab): AST hierarchy from parsed code
- **Code Editor** (center): AvalonEdit with live analysis
- **Object Tree** (right): Runtime instances during execution

---

## Part 3: Compiler & Runtime Comparison

### 3.1 Compilation Pipeline

#### BYOND Dream Maker
```
Source (.dm, .dme, .dmm, .dmi)
  ↓
Preprocessor (#define, #include resolution)
  ↓
Lexer (tokenize, handle indentation)
  ↓
Parser (syntax tree)
  ↓
Semantic Analyzer (type checking, scope validation)
  ↓
Code Generator (bytecode emission)
  ↓
Bytecode Optimizer (peephole optimization)
  ↓
Artifacts: .dmb (bytecode), .rsc (resources)
```

#### Craft++
```
Source (.dm, .dme, .dmm, .dmi)
  ↓
Preprocessor (#define, #include via DmCompiler)
  ↓
Lexer (tokenize, indentation→braces)
  ↓
Parser (recursive-descent, builds AST)
  ↓
[No separate semantic pass; type checking deferred]
  ↓
AST Interpreter (tree-walking execution)
  ↓
Artifacts: .dmb/.rsc (ZIP with source + manifest)
```

### 3.2 Runtime Execution Model

#### BYOND Dream Daemon
- **Process Model:** Standalone server, accepts network connections
- **Threading:** Async I/O, single-threaded game loop (tick-based)
- **Memory:** Bytecode VM heap, garbage collection
- **Object Lifecycle:** Created with `new`, destroyed with `del` or GC
- **Execution:** Bytecode interpreter (JIT in modern versions)

#### Craft++ Interpreter
- **Process Model:** In-process tree-walking interpreter
- **Threading:** Main thread executes AST, `spawn()` uses WorldScheduler
- **Memory:** C# managed heap (GC automatic)
- **Object Lifecycle:** CraftValue objects, explicit `del` registration
- **Execution:** Visitor pattern over AST nodes

### 3.3 Scoping & Variable Resolution

#### BYOND DM Variable Lookup
```
1. Local scope (function locals)
2. Proc scope (static state in proc)
3. Object scope (src.var_name)
4. Parent scope (via ..())
5. Global scope (world vars)
```

#### Craft++ Variable Lookup
```
1. Local scope (function Environment)
2. Enclosing scope (function closure)
3. Self scope (_self object vars)
4. Parent proc scope (via ..())
5. Global scope (Interpreter globals)
```

**Code (Interpreter.cs):**
```csharp
public CraftValue Get(string name)
{
    if (_values.TryGetValue(name, out var v)) return v;           // Local
    if (_self != null && _self.Vars.TryGetValue(name, out var sv)) 
        return sv;                                                  // Self
    if (_enclosing != null) return _enclosing.Get(name);          // Parent
    throw new Exception($"Undefined variable: {name}");
}
```

---

## Part 4: Dream Seeker Client Comparison

### 4.1 Client Architecture

#### BYOND Dream Seeker
- **Network Protocol:** Custom binary protocol over TCP/IP
- **Rendering:** Software (tiles, overlays, lighting)
- **Input:** Mouse click verbs, keyboard input, built-in controls
- **HUD:** Stat panels (`stat()` output), verb buttons, inventory display
- **Resolution:** Tile-based (configurable icon size)
- **Networking:** Async send/receive from Dream Daemon

#### Craft++ Dream Seeker (DreamSeekerWindow)
- **Network Protocol:** N/A (same process)
- **Rendering:** WPF Canvas, direct access to WorldRegistry
- **Input:** Mouse click verbs (Canvas click handlers), keyboard input
- **HUD:** Stat panels via stat() procs, verb list in sidebar
- **Resolution:** Pixel-perfect tile rendering (32x32 default)
- **Communication:** Shared memory, direct interpreter calls

### 4.2 Dream Seeker UI Components

#### BYOND Dream Seeker
```
┌─────────────────────────────────┐
│ [File][View][Help]  [⚙️ Settings]│
├─────────────────────────────────┤
│  ┌─────────────────────────────┐ │
│  │  Map Viewport               │ │
│  │  (tile rendering)           │ │
│  │                             │ │
│  │  [Verbs]  [Inventory]       │ │
│  │                             │ │
│  │  [Stat Panels]              │ │
│  └─────────────────────────────┘ │
│  Status: Connected              │ │
└─────────────────────────────────┘
```

#### Craft++ Dream Seeker (DreamSeekerWindow)
```
┌──────────────────────────────────┐
│ [File][View]  [Zoom+] [Zoom-]    │
├────────┬───────────────────────┤
│ World  │  Map Canvas           │ │
│ Verbs  │  (tile grid render)   │ │
│ Stat   │                       │ │
│        │  [X: 0] [Y: 0]        │ │
├────────┴───────────────────────┤
│ Status: Connected  FPS: 60      │
└──────────────────────────────────┘
```

### 4.3 Key Differences in Client Runtime

| Aspect | BYOND Dream Seeker | Craft++ Dream Seeker |
|--------|-------------------|---------------------|
| **Connection** | Network TCP socket | Same-process handle |
| **State Sync** | Periodic message parsing | Direct object tree access |
| **Map Viewport** | Software rasterization | WPF Canvas rendering |
| **Verb Execution** | Send to server, await response | Call proc directly in Interpreter |
| **Stat() Output** | Parse text display | Call stat() procs, render UI |
| **Click Handling** | Send coordinate click to server | Direct hit-test on WorldRegistry spatial grid |
| **Latency** | Network latency (multi-player) | Negligible (same process) |

---

## Part 5: Project Artifacts & Distribution

### 5.1 Build Output

#### BYOND Dream Maker
- **`.dmb`** — Compiled world bytecode (binary, proprietary format)
- **`.rsc`** — Resource cache (sprites, maps, icons)
- **Standalone**.** — Packaged .dmb + .rsc ZIP (for distribution)

#### Craft++
- **`.dmb`** — Self-hosted ZIP artifact with:
  - `manifest.json` (metadata)
  - `source/` (compiled source code as string)
  - `resources/` (icon, map, etc.)
- **`.rsc`** — Resource ZIP (icons, sounds, etc.)
- **Future** — Bytecode IR (planned, not AST packaging)

### 5.2 Deployment Model

#### BYOND
```
Developer writes .dm files
  ↓
Dream Maker compiles → .dmb + .rsc
  ↓
Deploy .dmb to Dream Daemon server
  ↓
Dream Seeker clients connect to server
```

#### Craft++
```
Developer writes .dm/.craft files
  ↓
Craft++ compiles → .dmb ZIP + .rsc ZIP
  ↓
Run in embedded Dream Seeker (same IDE window)
  ↓
[Future] Deploy standalone runtime
```

---

## Part 6: Known Gaps & Intentional Differences

### 6.1 Not Yet Implemented (Craft++)

1. **Networking** — No Dream Daemon equivalent; single-player only
2. **Bytecode Backend** — Currently ships AST; planned bytecode VM
3. **Complete Preprocessor** — No function-like macros (`#define M(x)`)
4. **Full DMI Support** — Icon state extraction works; full pixel editing incomplete
5. **Browser/HTML** — No built-in web rendering
6. **Grid Positioning** — Z-levels supported; 3D/viewport culling partial
7. **DM Semantics Edge Cases** — Lax type coercion, relative paths, etc.

### 6.2 Intentional Improvements over BYOND

1. **Consistent Indentation** — Automatic brace injection (no dialect switching)
2. **Modern OOP** — Plans for explicit inheritance syntax
3. **Type Enforcement** — Stricter path matching at parse time
4. **Integrated IDE** — Editor, compiler, client in one WPF app
5. **Live Feedback** — Real-time syntax errors, object tree during execution
6. **Transparent Artifacts** — Source-based .dmb (human-readable), not binary

---

## Part 7: Code Architecture Comparison

### 7.1 Lexer Architecture

#### BYOND DM Lexer
- Hand-written, state machine
- Handles BYOND-specific tokens (slash paths, indentation)
- Produces token stream

#### Craft++ Lexer (Lexer.cs)
```csharp
public List<Token> Tokenize()
{
    var tokens = new List<Token>();
    while (!IsAtEnd())
    {
        _start = _current;
        var c = Peek();
        if (char.IsWhiteSpace(c)) Advance();          // Skip whitespace
        else if (c == '/' && ...) SkipComment();       // Handle comments
        else tokens.Add(ScanToken());                  // Emit token
    }
    // If no braces found, convert indentation to braces
    if (!tokens.Any(t => t.Type == TokenType.LeftBrace))
        return ProcessIndentation(tokens);            // Auto-indent→brace
    return tokens;
}
```

### 7.2 Parser Architecture

#### BYOND DM Parser
- Recursive descent (typically)
- Builds semantic tree during parse (mixed phases)
- One-pass compilation

#### Craft++ Parser (Parser.cs)
```csharp
public List<Stmt> Parse()
{
    var statements = new List<Stmt>();
    while (!IsAtEnd())
        statements.Add(Declaration());               // Top-level decls
    return statements;
}

private Stmt Declaration()
{
    if (Match(TokenType.Var))
        return VarDeclaration();                      // var/x = ...
    if (Check(TokenType.Slash))
        return PathOrClassDeclaration();              // /mob { }
    if (Check(TokenType.Proc))
        return ProcDeclaration();                     // proc/Name() { }
    return ExpressionStatement();                     // expr;
}
```

### 7.3 Interpreter Architecture

#### BYOND Dream Daemon
- Bytecode VM (stack-based or register-based)
- Async I/O, network multiplexing
- Tick-based world loop

#### Craft++ Interpreter (Interpreter.cs)
```csharp
public class Interpreter
{
    private Environment _globals = new();

    public void Execute(List<Stmt> statements)
    {
        foreach (var stmt in statements)
            stmt.Accept(this);                        // Visitor pattern
    }

    public object? VisitExprStmt(ExprStmt stmt)
    {
        EvaluateExpression(stmt.Expr);
        return null;
    }

    public object? VisitVarStmt(VarStmt stmt)
    {
        var val = EvaluateExpression(stmt.Initializer);
        _globals.Define(stmt.Name, val as CraftValue ?? CraftValue.Null());
        return null;
    }
}
```

### 7.4 Type System Architecture

#### BYOND Type Inference
- Loose: `var/x` can hold any type
- Strict: `var/mob/x` enforces `/mob` or subclass
- Runtime checking (deferred)

#### Craft++ Type System
- **CraftValue** — Wrapper around all DM values
  - `Type` — string path (e.g., `/mob/player`)
  - `Vars` — dictionary of properties
  - `ProcTable` — bound procedures
- **Type Path Matching** — `istype()` / `as` operators

```csharp
public class CraftValue
{
    public string Type { get; set; }                  // /mob/player
    public Dictionary<string, CraftValue> Vars { get; } = new();
    public Dictionary<string, Proc> ProcTable { get; } = new();
    
    public CraftValue? GetVar(string name)
    {
        if (Vars.TryGetValue(name, out var v)) return v;
        return null;
    }
}
```

---

## Part 8: Summary Table

| Category | BYOND DM | Craft++ |
|----------|----------|---------|
| **Language Generation** | 1994–present (legacy + modern) | 2020s (clean slate) |
| **Compilation** | Bytecode VM (proprietary) | Tree-walking interpreter |
| **Architecture** | Client-server (network) | Single-process (shared memory) |
| **IDE** | Native C++ app | WPF desktop app |
| **Editor** | Built-in editor | AvalonEdit (Monaco-like) |
| **Debugging** | Debugger + breakpoints | DebuggerService (planned) |
| **Preprocessor** | Full macro support | Basic #define / #undef |
| **Type System** | Weak (late binding) | Strong (early checking) |
| **Indentation** | User chooses | Auto-converted to braces |
| **OOP** | Slash paths + inheritance | Slash paths + explicit inheritance (planned) |
| **Distribution** | Binary .dmb + .rsc | Source-based .dmb ZIP + .rsc |
| **Networking** | Dream Daemon + Dream Seeker | Single-process (no network) |
| **File Format** | Binary bytecode | ZIP with manifest + source |
| **Object Tree** | Runtime registry | WorldRegistry + spatial grid |
| **Verbs** | Network RPC | Direct proc calls |
| **Future** | Maintenance mode | Active development |

---

## Conclusion

**Craft++** is a spiritual successor to BYOND Dream Maker that trades binary compatibility for modernization. It captures the essence of DM (object hierarchies, verbs, stat panels) while providing:

1. **Integrated IDE** — No separate compiler/runtime/client
2. **Transparent Architecture** — AST-based, source-visible artifacts
3. **Clean Semantics** — Strict type paths, consistent indentation
4. **Modern OOP** — Plans for inheritance syntax improvements
5. **Developer Experience** — Live syntax checking, real-time object tree

Craft++ is **not a BYOND clone** but an **intentional redesign** for developers who love DM's syntax but want a modern, maintainable platform.

---

## References

- [BYOND Official Documentation](https://www.byond.com/)
- [BYOND Dream Maker Reference](https://www.byond.com/docs/ref/)
- Craft++ Source Code (in this workspace)
- [BYOND_COMPATIBILITY.md](./BYOND_COMPATIBILITY.md)
- [README.md](./README.md)