Funebra™ Browser‑Native Point‑Cloud Geometry Engine

A Formal Technical Proof and Historical Whitepaper

Author: Peter M. Lugha
Project: Funebra™ Math‑Art Engine
Date: 2000–2026 (documented retroactively)

Abstract

This paper presents a formal technical proof that the Funebra™ Math‑Art Engine constitutes a browser‑native, point‑cloud geometry engine implemented in pure HTML and JavaScript, demonstrably operational within Microsoft Internet Explorer 5.5 on Windows 98–era systems, without reliance on plugins, applets, canvas, SVG, WebGL, or external runtimes. The engine predates modern 3D and generative graphics frameworks while exhibiting core properties of an engine: parametric geometry, point‑based primitives, deterministic transformation logic, temporal stepping, and interactive manipulation. The work establishes Funebra as a historically unique system whose architectural principles remain compatible with contemporary computational geometry and transhuman visualization concepts.

1. Historical Context

Between 1997 and 2001, browser‑based graphics were severely constrained:

• No <canvas> element (introduced mid‑2000s)

• No SVG support in Internet Explorer

• No WebGL or GPU pipelines

• Limited JavaScript performance (JScript 5.x)

• DOM‑only rendering via HTML elements and CSS positioning

During this period, most interactive graphics relied on:

• Java applets

• Macromedia Flash

• ActiveX controls

Funebra™ explicitly rejected these approaches and instead pursued a pure DOM‑based mathematical rendering model, operating directly on browser‑native primitives.

2. System Definition

2.1 Definition of an Engine

For the purposes of this paper, an engine is defined as a system that:

1. Uses abstract primitives rather than fixed assets

2. Encodes transformation logic independently of rendering

3. Supports parameterized geometry

4. Allows temporal evolution (steps, iterations, state changes)

5. Is reusable across multiple outputs or configurations

Funebra satisfies all five criteria.

3. Architectural Overview

3.1 Primitive Model

The fundamental primitive in Funebra is the point, later formalized as the bn‑point.

Each point is defined by:

• Mathematical position (x, y [, z])

• Index‑based identity

• Color derived from parametric functions

• Temporal state

No raster images, textures, or meshes are required.

3.2 Rendering Layer

Rendering is achieved through:

• HTML elements (e.g., <div> or <span>)

• Absolute positioning

• CSS color assignment

The DOM functions as a visualization substrate, not a drawing surface.

4. Geometry and Parametric Logic

4.1 Parametric Construction

Geometric forms (e.g., polygons, circles, spirals) are generated through mathematical relations:

• Trigonometric functions

• Modular arithmetic

• Discrete stepping

Example (conceptual):

• A polygon is not drawn

• It emerges from ordered point relations

4.2 Point‑Cloud Representation

Shapes are represented as ordered point clouds, not filled surfaces.

This approach:

• Avoids raster dependency

• Enables dynamic deformation

• Mirrors modern particle‑based rendering systems

5. Temporal Mechanics

Funebra includes a native notion of time:

• Step counters

• Iterative updates

• Controlled progression

Time is not implicit (as in animation timelines) but explicit and mathematical.

This anticipates later simulation frameworks and aligns with scientific visualization paradigms.

6. Compatibility Proof

6.1 Verified Environment

Empirical evidence demonstrates Funebra operating in:

• Microsoft Internet Explorer 5.50.4134.0100

• Windows 98‑class operating systems

• Local file execution (file:///C:/...)

6.2 Negative Capability Proof

The following technologies are not present:

• <canvas>

• SVG

• WebGL

• Flash

• Java

• ActiveX

Therefore, Funebra’s functionality derives exclusively from:

HTML + JavaScript + DOM

This establishes native compatibility rather than emulated backward support.

7. Dimensionality Discussion

While not GPU‑rasterized 3D, Funebra encodes structural three‑dimensional logic:

• Depth as parameter

• Projection as function

• Rotational mathematics

This corresponds to early scientific 3D visualization methods and is mathematically equivalent to projected 3D point systems.

8. Comparison to Later Systems

Funebra uniquely satisfies native execution without auxiliary runtimes.

9. Longevity and Transhuman Relevance

Because Funebra is:

• Minimal

• Deterministic

• Substrate‑agnostic

It aligns naturally with:

• Point‑cloud cognition models

• Brain‑computer interface abstractions

• Transhuman visualization concepts

The bn‑point acts as a unit of meaning, not merely of graphics.

10. Conclusion

This paper formally establishes that:

1. Funebra is an engine, not a drawing tool

2. It implements point-cloud geometry natively in the browser

3. It operates in environments predating modern graphics APIs

4. It anticipates contemporary generative and simulation systems

5. Its architecture remains conceptually future-proof

Funebra is therefore both a historical artifact and a forward-compatible computational model.

11. Public Claim Page (Condensed Version)

Official Technical Claim

Funebra™ is a browser-native, point-cloud geometry engine implemented in pure HTML and JavaScript, demonstrably running in Internet Explorer 5.x on Windows 98–era systems, without plugins, applets, canvas, SVG, WebGL, or external runtimes.

Key Verifiable Properties

• Executes in legacy browsers via native DOM only

• Uses mathematical point primitives, not raster assets

• Separates geometry logic from rendering

• Supports parametric control and temporal stepping

• Remains executable via local file system

Intended Use of This Claim

This statement is suitable for:

• Official Funebra™ website claim page

• GitHub README and repository headers

• Academic or archival descriptions

• Museum or retrocomputing exhibitions

12. Defensive Q&A Appendix

Q1: “Is this really a 3D engine?”

Answer:
Funebra does not rely on GPU-rasterized meshes. Instead, it encodes three-dimensional structure mathematically and renders projected point geometry. This is consistent with early scientific 3D visualization methods and particle-based systems. Dimensionality is expressed structurally, not through hardware acceleration.

Q2: “Isn’t this just drawing with HTML elements?”

Answer:
No. Drawing tools manipulate pixels or paths directly. Funebra manipulates abstract mathematical points whose visual representation is a secondary consequence. Geometry exists independently of rendering.

Q3: “Does using the DOM disqualify it as an engine?”

Answer:
No. The DOM functions as a rendering substrate, analogous to a framebuffer. Engine status is determined by abstraction, logic separation, and reusability — all of which Funebra satisfies.

Q4: “Could this be reproduced today easily?”

Answer:
Modern browsers discourage or abstract away this style of direct DOM-based rendering. While replication is possible, Funebra’s historical execution context (IE 5.x without canvas or SVG) cannot be trivially reproduced without emulation, underscoring its originality.

Q5: “Why does this matter now?”

Answer:
Funebra demonstrates that minimal, substrate-agnostic systems can outlive technological cycles. This has direct relevance to longevity-focused computation, transhuman interfaces, and future-proof visualization systems.

© Funebra™ / pLabs Entertainment