Welcome to EBAL2D
EBAL2D is a browser-native 2D game engine and creation platform currently in active development.
Our goal is to make building and sharing 2D games more direct:
• create projects in the browser;
• design worlds and gameplay in EBAL2D Studio;
• launch playable previews instantly;
• export independent release builds.
This channel is the official EBAL2D development log. Here you will find:
• major development milestones;
• Studio and engine progress;
• screenshots and playable previews;
• architecture and technology highlights;
• roadmap and release updates.
EBAL2D is still being built from the foundation up. We will share real progress, explain important decisions and clearly distinguish between what is planned, what is in development and what is already working.
Follow the journey and use reactions to let us know which updates you find most interesting.
🌐 https://ebal2d.com
EBAL2D is a browser-native 2D game engine and creation platform currently in active development.
Our goal is to make building and sharing 2D games more direct:
• create projects in the browser;
• design worlds and gameplay in EBAL2D Studio;
• launch playable previews instantly;
• export independent release builds.
This channel is the official EBAL2D development log. Here you will find:
• major development milestones;
• Studio and engine progress;
• screenshots and playable previews;
• architecture and technology highlights;
• roadmap and release updates.
EBAL2D is still being built from the foundation up. We will share real progress, explain important decisions and clearly distinguish between what is planned, what is in development and what is already working.
Follow the journey and use reactions to let us know which updates you find most interesting.
🌐 https://ebal2d.com
Development Update #001 — The Road to Playable Previews
EBAL2D has reached an important architecture milestone: the design of the project-to-preview pipeline is now complete and accepted.
This pipeline will transform a project created in EBAL2D Studio into a deterministic, browser-playable preview.
The architecture establishes several important principles:
• the same project data must always produce a predictable result;
• Studio and Preview remain clearly separated;
• projects can run without turning the editor itself into the game runtime;
• the foundation remains suitable for future testing, sharing and release exports.
Current status
✅ Preview architecture accepted
🟡 Implementation is the next step
⚪️ A public playable preview is not available yet
Next, we will begin building the first complete path from an EBAL2D project to a running browser preview.
EBAL2D is being built foundation-first. Every completed milestone brings us closer to creating, testing and sharing real 2D games directly through the browser.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has reached an important architecture milestone: the design of the project-to-preview pipeline is now complete and accepted.
This pipeline will transform a project created in EBAL2D Studio into a deterministic, browser-playable preview.
The architecture establishes several important principles:
• the same project data must always produce a predictable result;
• Studio and Preview remain clearly separated;
• projects can run without turning the editor itself into the game runtime;
• the foundation remains suitable for future testing, sharing and release exports.
Current status
✅ Preview architecture accepted
🟡 Implementation is the next step
⚪️ A public playable preview is not available yet
Next, we will begin building the first complete path from an EBAL2D project to a running browser preview.
EBAL2D is being built foundation-first. Every completed milestone brings us closer to creating, testing and sharing real 2D games directly through the browser.
🌐 https://ebal2d.com
#EBAL2D #Devlog
👍2
Why We Are Building EBAL2D
Creating a 2D game often begins long before the first scene appears: installing tools, configuring a project, preparing the runtime and finding a convenient way to share the result.
We believe that process can be more direct.
EBAL2D is being built as a browser-native 2D game engine and creation platform — a connected environment where developers will be able to create a project, test it in a playable preview and export an independent release build.
The browser is not just a place where the final game runs. It is the foundation of the entire workflow.
Our long-term goal is to make 2D game creation:
• easier to access;
• faster to test and share;
• predictable across environments;
• independent from the EBAL2D platform after export.
This does not mean removing depth or hiding every technical decision. It means reducing unnecessary friction while preserving control over the project and its final build.
EBAL2D is still in active development. Today, we are building the architecture and runtime foundations required to make this vision reliable.
That is why we are starting from the foundation — and sharing the journey as it happens.
🌐 https://ebal2d.com
#EBAL2D #Devlog
Creating a 2D game often begins long before the first scene appears: installing tools, configuring a project, preparing the runtime and finding a convenient way to share the result.
We believe that process can be more direct.
EBAL2D is being built as a browser-native 2D game engine and creation platform — a connected environment where developers will be able to create a project, test it in a playable preview and export an independent release build.
The browser is not just a place where the final game runs. It is the foundation of the entire workflow.
Our long-term goal is to make 2D game creation:
• easier to access;
• faster to test and share;
• predictable across environments;
• independent from the EBAL2D platform after export.
This does not mean removing depth or hiding every technical decision. It means reducing unnecessary friction while preserving control over the project and its final build.
EBAL2D is still in active development. Today, we are building the architecture and runtime foundations required to make this vision reliable.
That is why we are starting from the foundation — and sharing the journey as it happens.
🌐 https://ebal2d.com
#EBAL2D #Devlog
🤝2
Development Update #002 — The First Project-to-Preview Slice Is Complete
In our previous development update, we shared the architecture behind the EBAL2D Preview pipeline.
Today, that architecture has become a working foundation.
We have completed and accepted the first end-to-end Project-to-Preview vertical slice. The core parts of EBAL2D can now work together to transform project data, run it through the browser runtime and produce a verified rendered result.
This milestone brings together:
• the deterministic project build path;
• the Runtime and WebAssembly boundary;
• the Browser Host and Preview lifecycle;
• asset loading and runtime residency;
• the rendering pipeline;
• automated and browser-level verification.
The result is not yet a public playable Preview or a complete editor. It is the verified technical path on which those experiences can now be built.
Current status
✅ Project-to-Preview vertical slice complete
✅ Preview verification and audits complete
🟡 Studio shell planning has begun
⚪️ Public Studio and Preview are not available yet
The next stage is focused on establishing the first honest EBAL2D Studio shell — the browser environment where projects will eventually be created and sent into the Preview pipeline.
The foundation is now moving from isolated engine capabilities toward a real creation workflow.
🌐 https://ebal2d.com
📢 https://t.me/ebal2d
#EBAL2D #Devlog
In our previous development update, we shared the architecture behind the EBAL2D Preview pipeline.
Today, that architecture has become a working foundation.
We have completed and accepted the first end-to-end Project-to-Preview vertical slice. The core parts of EBAL2D can now work together to transform project data, run it through the browser runtime and produce a verified rendered result.
This milestone brings together:
• the deterministic project build path;
• the Runtime and WebAssembly boundary;
• the Browser Host and Preview lifecycle;
• asset loading and runtime residency;
• the rendering pipeline;
• automated and browser-level verification.
The result is not yet a public playable Preview or a complete editor. It is the verified technical path on which those experiences can now be built.
Current status
✅ Project-to-Preview vertical slice complete
✅ Preview verification and audits complete
🟡 Studio shell planning has begun
⚪️ Public Studio and Preview are not available yet
The next stage is focused on establishing the first honest EBAL2D Studio shell — the browser environment where projects will eventually be created and sent into the Preview pipeline.
The foundation is now moving from isolated engine capabilities toward a real creation workflow.
🌐 https://ebal2d.com
📢 https://t.me/ebal2d
#EBAL2D #Devlog
Telegram
EBAL2D — Devlog
Official development log for EBAL2D — a browser-native 2D game engine and creation platform.
Development updates, architecture milestones, previews and release notes.
https://ebal2d.com
Development updates, architecture milestones, previews and release notes.
https://ebal2d.com
👍1
Development Update #003 — The First Studio Foundation Is Complete
The first internal foundation of EBAL2D Studio has been completed and accepted.
Studio can now open a project, establish an active project session and display it through the real EBAL2D Preview pipeline inside the browser workspace.
This milestone brings together:
• the initial Studio workspace shell;
• project opening and session management;
• read-only project structure and selection;
• the production Preview runtime embedded into Studio;
• browser and WebGPU lifecycle handling;
• automated and browser-level verification.
This is an important transition for EBAL2D. The engine and Preview pipeline are no longer isolated technical components — they now operate as part of the first verified creation workflow.
Current status
✅ Internal Studio foundation complete
✅ Project-to-Preview integration verified
✅ Browser-level Studio validation complete
⚪️ Public Studio is not available yet
⚪️ Authoring, saving and visual editing are still ahead
The next development stage will focus on the typed intermediate representation and compiler — the foundation required for future visual logic and executable game behavior.
EBAL2D Studio is beginning to take shape, one verified layer at a time.
🌐 https://ebal2d.com
#EBAL2D #Devlog
The first internal foundation of EBAL2D Studio has been completed and accepted.
Studio can now open a project, establish an active project session and display it through the real EBAL2D Preview pipeline inside the browser workspace.
This milestone brings together:
• the initial Studio workspace shell;
• project opening and session management;
• read-only project structure and selection;
• the production Preview runtime embedded into Studio;
• browser and WebGPU lifecycle handling;
• automated and browser-level verification.
This is an important transition for EBAL2D. The engine and Preview pipeline are no longer isolated technical components — they now operate as part of the first verified creation workflow.
Current status
✅ Internal Studio foundation complete
✅ Project-to-Preview integration verified
✅ Browser-level Studio validation complete
⚪️ Public Studio is not available yet
⚪️ Authoring, saving and visual editing are still ahead
The next development stage will focus on the typed intermediate representation and compiler — the foundation required for future visual logic and executable game behavior.
EBAL2D Studio is beginning to take shape, one verified layer at a time.
🌐 https://ebal2d.com
#EBAL2D #Devlog
👍1
Development Update #004 — The First Project Compilation Path Is Complete
EBAL2D has completed and accepted its first project compilation foundation.
A project can now pass through a verified compilation path built around Typed IR — a shared intermediate representation that defines executable game behavior independently from how that behavior was authored.
This milestone establishes:
• a typed semantic model for project logic;
• deterministic compilation and output ordering;
• structured diagnostics for invalid project data;
• a stable boundary between authoring tools and the runtime;
• a shared foundation for future visual logic and TypeScript scripting.
This is an important architectural step. Future authoring methods will not become separate execution systems — they will translate into the same semantic model and follow the same verified path into Preview.
Current status
✅ Typed IR foundation complete
✅ First project compilation path accepted
✅ Compiler diagnostics and deterministic behavior verified
🟡 Visual programming and TypeScript integration are the current development focus
⚪️ Public authoring tools are not available yet
⚪️ The complete creator workflow remains in development
The next stage will connect structured visual logic and a bounded TypeScript path to this shared foundation.
EBAL2D is moving from displaying project content toward defining and executing real game behavior.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted its first project compilation foundation.
A project can now pass through a verified compilation path built around Typed IR — a shared intermediate representation that defines executable game behavior independently from how that behavior was authored.
This milestone establishes:
• a typed semantic model for project logic;
• deterministic compilation and output ordering;
• structured diagnostics for invalid project data;
• a stable boundary between authoring tools and the runtime;
• a shared foundation for future visual logic and TypeScript scripting.
This is an important architectural step. Future authoring methods will not become separate execution systems — they will translate into the same semantic model and follow the same verified path into Preview.
Current status
✅ Typed IR foundation complete
✅ First project compilation path accepted
✅ Compiler diagnostics and deterministic behavior verified
🟡 Visual programming and TypeScript integration are the current development focus
⚪️ Public authoring tools are not available yet
⚪️ The complete creator workflow remains in development
The next stage will connect structured visual logic and a bounded TypeScript path to this shared foundation.
EBAL2D is moving from displaying project content toward defining and executing real game behavior.
🌐 https://ebal2d.com
#EBAL2D #Devlog
Development Update #005 — Two Authoring Paths, One Foundation
EBAL2D has completed and accepted the first authoring layer built on top of its shared compilation foundation.
Project behavior can now be described through two verified paths:
• structured visual logic;
• a bounded TypeScript project module.
Both paths are translated into the same canonical Typed IR, compiled through the same deterministic pipeline and delivered to the existing Preview runtime.
This means visual authoring and scripting do not become separate execution systems. They share one semantic model, one compiler boundary and the same rules for validation and diagnostics.
The TypeScript source is parsed and lowered into the shared representation — it is not executed directly. This keeps project behavior controlled, portable and predictable.
Current status
✅ Structured visual logic path complete
✅ Bounded TypeScript authoring path complete
✅ Shared compilation and Preview integration verified
✅ Automated and browser-level validation complete
⚪️ Public authoring tools are not available yet
⚪️ A complete visual editor and general-purpose scripting remain ahead
The next stage will focus on core 2D gameplay systems built on this foundation, including transforms, input, motion, collisions and camera behavior.
EBAL2D can now move from defining how game behavior is authored to building the systems that make it act inside the runtime.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted the first authoring layer built on top of its shared compilation foundation.
Project behavior can now be described through two verified paths:
• structured visual logic;
• a bounded TypeScript project module.
Both paths are translated into the same canonical Typed IR, compiled through the same deterministic pipeline and delivered to the existing Preview runtime.
This means visual authoring and scripting do not become separate execution systems. They share one semantic model, one compiler boundary and the same rules for validation and diagnostics.
The TypeScript source is parsed and lowered into the shared representation — it is not executed directly. This keeps project behavior controlled, portable and predictable.
Current status
✅ Structured visual logic path complete
✅ Bounded TypeScript authoring path complete
✅ Shared compilation and Preview integration verified
✅ Automated and browser-level validation complete
⚪️ Public authoring tools are not available yet
⚪️ A complete visual editor and general-purpose scripting remain ahead
The next stage will focus on core 2D gameplay systems built on this foundation, including transforms, input, motion, collisions and camera behavior.
EBAL2D can now move from defining how game behavior is authored to building the systems that make it act inside the runtime.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #006 — Core 2D Gameplay Systems Are Running
EBAL2D has completed and accepted its first integrated set of core 2D gameplay systems.
The engine can now take structured project behavior through the shared compilation pipeline and execute it as part of a deterministic gameplay session.
This milestone brings together:
• logical player input;
• spatial and transform state;
• velocity-based movement;
• fixed-step simulation;
• collision processing;
• camera behavior;
• presentation of the resulting game state.
These systems are not isolated prototypes. They are connected to the existing EBAL2D creation path:
authoring → Typed IR → compiled Runtime program → gameplay execution → Preview
The complete path has also been verified through the real Studio-to-Preview workflow in Chromium.
Current status
✅ Core 2D gameplay systems complete
✅ Deterministic gameplay scheduling verified
✅ Compiled behavior connected to the Runtime
✅ Studio-to-Preview browser path verified
⚪️ Public Studio and Preview are not available yet
⚪️ Complete gameplay tooling and authoring UI remain in development
The next stage will focus on validating a versioned plugin boundary for future community-created authoring blocks, while keeping executable game behavior inside the same controlled Typed IR pipeline.
EBAL2D has moved beyond defining game behavior — the first complete gameplay foundation is now running through the engine.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted its first integrated set of core 2D gameplay systems.
The engine can now take structured project behavior through the shared compilation pipeline and execute it as part of a deterministic gameplay session.
This milestone brings together:
• logical player input;
• spatial and transform state;
• velocity-based movement;
• fixed-step simulation;
• collision processing;
• camera behavior;
• presentation of the resulting game state.
These systems are not isolated prototypes. They are connected to the existing EBAL2D creation path:
authoring → Typed IR → compiled Runtime program → gameplay execution → Preview
The complete path has also been verified through the real Studio-to-Preview workflow in Chromium.
Current status
✅ Core 2D gameplay systems complete
✅ Deterministic gameplay scheduling verified
✅ Compiled behavior connected to the Runtime
✅ Studio-to-Preview browser path verified
⚪️ Public Studio and Preview are not available yet
⚪️ Complete gameplay tooling and authoring UI remain in development
The next stage will focus on validating a versioned plugin boundary for future community-created authoring blocks, while keeping executable game behavior inside the same controlled Typed IR pipeline.
EBAL2D has moved beyond defining game behavior — the first complete gameplay foundation is now running through the engine.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #007 — A Safe Foundation for Future Plugins
EBAL2D has completed and accepted its first versioned Plugin ABI foundation.
This establishes a controlled boundary through which future plugins will be able to extend authoring capabilities without introducing a separate game runtime or bypassing the existing Typed IR pipeline.
The completed foundation includes:
• explicit API, ABI, schema and package versioning;
• deny-by-default, scoped plugin capabilities;
• lifecycle and generation-safe replacement rules;
• atomic registry updates and rollback behavior;
• compatibility and conformance validation;
• automated verification integrated into CI.
Executable game behavior remains inside the same deterministic pipeline used by EBAL2D projects. Plugins cannot silently introduce an alternative compiler, runtime, scheduler or rendering path.
Current status
✅ Versioned Plugin ABI foundation complete
✅ Capability and lifecycle boundaries accepted
✅ Registry and atomic update behavior verified
✅ Conformance and CI verification complete
⚪️ Public plugin marketplace is not available
⚪️ Hosted moderation and benchmarking services remain future work
⚪️ Arbitrary executable plugins are not supported
The next stage will focus on production asset streaming: loading, residency budgets, GPU uploads, deterministic eviction and safe reloading inside Preview.
EBAL2D can now grow toward an extensible ecosystem without compromising the predictable foundation already built.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted its first versioned Plugin ABI foundation.
This establishes a controlled boundary through which future plugins will be able to extend authoring capabilities without introducing a separate game runtime or bypassing the existing Typed IR pipeline.
The completed foundation includes:
• explicit API, ABI, schema and package versioning;
• deny-by-default, scoped plugin capabilities;
• lifecycle and generation-safe replacement rules;
• atomic registry updates and rollback behavior;
• compatibility and conformance validation;
• automated verification integrated into CI.
Executable game behavior remains inside the same deterministic pipeline used by EBAL2D projects. Plugins cannot silently introduce an alternative compiler, runtime, scheduler or rendering path.
Current status
✅ Versioned Plugin ABI foundation complete
✅ Capability and lifecycle boundaries accepted
✅ Registry and atomic update behavior verified
✅ Conformance and CI verification complete
⚪️ Public plugin marketplace is not available
⚪️ Hosted moderation and benchmarking services remain future work
⚪️ Arbitrary executable plugins are not supported
The next stage will focus on production asset streaming: loading, residency budgets, GPU uploads, deterministic eviction and safe reloading inside Preview.
EBAL2D can now grow toward an extensible ecosystem without compromising the predictable foundation already built.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #008 — Production Asset Streaming Is Complete
EBAL2D has completed and accepted its production asset streaming foundation.
The engine can now coordinate asset loading, manage CPU and GPU residency, enforce memory budgets and safely move resources through their runtime lifecycle.
The completed system includes:
• coordinated asset requests and loading;
• controlled CPU and GPU residency;
• budget-aware resource admission;
• physical uploads to the Renderer;
• deterministic eviction under memory pressure;
• safe cancellation, replacement and reloading;
• lifecycle protection against stale asynchronous results.
The complete asset path has been verified through automated checks, fresh-process testing and real Chromium WebGPU browser runs.
This is an internal engine milestone. It does not yet mean that a public Studio, Preview or release workflow is available. It establishes the resource-management foundation those experiences will depend on as projects become larger and more complex.
Current status
✅ Production asset streaming complete
✅ CPU and GPU residency control verified
✅ Deterministic budget and eviction behavior accepted
✅ Chromium WebGPU validation complete
🟡 Deterministic parallel execution is the next development focus
⚪️ Public Studio and Preview are not available yet
The next stage will explore how EBAL2D can execute independent work in parallel while preserving deterministic results, stable diagnostics and predictable scheduling.
EBAL2D can now manage game assets as a real runtime system rather than a collection of individually loaded resources.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted its production asset streaming foundation.
The engine can now coordinate asset loading, manage CPU and GPU residency, enforce memory budgets and safely move resources through their runtime lifecycle.
The completed system includes:
• coordinated asset requests and loading;
• controlled CPU and GPU residency;
• budget-aware resource admission;
• physical uploads to the Renderer;
• deterministic eviction under memory pressure;
• safe cancellation, replacement and reloading;
• lifecycle protection against stale asynchronous results.
The complete asset path has been verified through automated checks, fresh-process testing and real Chromium WebGPU browser runs.
This is an internal engine milestone. It does not yet mean that a public Studio, Preview or release workflow is available. It establishes the resource-management foundation those experiences will depend on as projects become larger and more complex.
Current status
✅ Production asset streaming complete
✅ CPU and GPU residency control verified
✅ Deterministic budget and eviction behavior accepted
✅ Chromium WebGPU validation complete
🟡 Deterministic parallel execution is the next development focus
⚪️ Public Studio and Preview are not available yet
The next stage will explore how EBAL2D can execute independent work in parallel while preserving deterministic results, stable diagnostics and predictable scheduling.
EBAL2D can now manage game assets as a real runtime system rather than a collection of individually loaded resources.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
👍1
Development Update #009 — Deterministic Parallel Execution Is Complete
EBAL2D has completed and accepted its first deterministic parallel execution foundation.
The engine can now identify eligible independent work, execute it concurrently and publish the results through a controlled ordering boundary.
The central requirement was not simply to introduce parallelism, but to preserve the predictable behavior already established across the engine.
The completed foundation includes:
• dependency-aware scheduling of parallel work;
• deterministic ordering of observable results;
• controlled handling of conflicting operations;
• protection against stale and cancelled work;
• stable diagnostics and failure behavior;
• verified fallback paths when parallel execution is unavailable or unsuitable;
• automated and browser-level validation.
The same project inputs must continue to produce the same externally observable result regardless of worker timing or completion order.
Current status
✅ Deterministic parallel execution foundation complete
✅ Scheduling and result ordering verified
✅ Cancellation and stale-result protection accepted
✅ Browser execution path validated
⚪️ Parallel execution does not automatically accelerate every workload
⚪️ Public Studio and Preview are not available yet
This milestone gives EBAL2D a controlled path toward using modern hardware more effectively without sacrificing reproducibility or predictable gameplay behavior.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted its first deterministic parallel execution foundation.
The engine can now identify eligible independent work, execute it concurrently and publish the results through a controlled ordering boundary.
The central requirement was not simply to introduce parallelism, but to preserve the predictable behavior already established across the engine.
The completed foundation includes:
• dependency-aware scheduling of parallel work;
• deterministic ordering of observable results;
• controlled handling of conflicting operations;
• protection against stale and cancelled work;
• stable diagnostics and failure behavior;
• verified fallback paths when parallel execution is unavailable or unsuitable;
• automated and browser-level validation.
The same project inputs must continue to produce the same externally observable result regardless of worker timing or completion order.
Current status
✅ Deterministic parallel execution foundation complete
✅ Scheduling and result ordering verified
✅ Cancellation and stale-result protection accepted
✅ Browser execution path validated
⚪️ Parallel execution does not automatically accelerate every workload
⚪️ Public Studio and Preview are not available yet
This milestone gives EBAL2D a controlled path toward using modern hardware more effectively without sacrificing reproducibility or predictable gameplay behavior.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #010 — The Debugger and Profiler Foundation Is Complete
EBAL2D has completed its first internal debugger and profiler foundation.
The engine can now collect structured execution data from the real gameplay runtime and carry it through the existing Runtime, WebAssembly and Studio toolchain.
The completed foundation establishes:
• deterministic ordering of captured runtime data;
• bounded profiling buffers and controlled memory use;
• lifecycle protection against stale results;
• explicit reporting when a metric cannot be measured reliably;
• integration with the authentic gameplay execution path;
• automated audits and independent clean-room verification.
This is an internal tooling milestone. It does not yet mean that a complete public debugger or profiler interface is available in Studio.
One hosted-environment verification item also remains deferred. The stage has been closed with that limitation recorded rather than treating an unavailable hosted check as completed.
Current status
✅ Internal debugger and profiler foundation complete
✅ Runtime capture and composition verified
✅ Deterministic, bounded telemetry accepted
✅ Independent clean-room verification complete
🟡 Hosted-environment verification remains deferred
🟡 Project-specific optimization is the current development focus
⚪️ Public debugging and profiling tools are not available yet
The next stage will use measurement-driven optimization plans to improve real EBAL2D workloads without compromising determinism, correctness or stable fallback behavior.
EBAL2D can now begin optimizing from evidence rather than assumptions.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed its first internal debugger and profiler foundation.
The engine can now collect structured execution data from the real gameplay runtime and carry it through the existing Runtime, WebAssembly and Studio toolchain.
The completed foundation establishes:
• deterministic ordering of captured runtime data;
• bounded profiling buffers and controlled memory use;
• lifecycle protection against stale results;
• explicit reporting when a metric cannot be measured reliably;
• integration with the authentic gameplay execution path;
• automated audits and independent clean-room verification.
This is an internal tooling milestone. It does not yet mean that a complete public debugger or profiler interface is available in Studio.
One hosted-environment verification item also remains deferred. The stage has been closed with that limitation recorded rather than treating an unavailable hosted check as completed.
Current status
✅ Internal debugger and profiler foundation complete
✅ Runtime capture and composition verified
✅ Deterministic, bounded telemetry accepted
✅ Independent clean-room verification complete
🟡 Hosted-environment verification remains deferred
🟡 Project-specific optimization is the current development focus
⚪️ Public debugging and profiling tools are not available yet
The next stage will use measurement-driven optimization plans to improve real EBAL2D workloads without compromising determinism, correctness or stable fallback behavior.
EBAL2D can now begin optimizing from evidence rather than assumptions.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
👍1
Studio, Preview and Release Builds
EBAL2D is being designed around three distinct parts of the game-creation workflow.
Studio is the creation environment.
It is where developers will manage projects, build scenes, define game behavior and work with assets. Studio coordinates the workflow, but it is not intended to become the game runtime itself.
Preview is the testing environment.
It takes a project through the real compilation and runtime pipeline, allowing the game to run inside the browser while remaining connected to Studio. This separation helps testing reflect how the project actually behaves instead of relying on an editor-only simulation.
Release builds are the final exported games.
The long-term goal is for exported projects to run independently, without requiring Studio or a permanent connection to EBAL2D services. Developers should retain control over where and how their games are distributed.
Together, these parts form one connected path:
Create in Studio → test in Preview → export an independent release
The internal Studio and Preview foundations are already being built and verified. The complete public workflow and release export system are still in development.
Keeping these environments separate from the beginning gives EBAL2D a clearer foundation for testing, sharing and distributing real 2D games.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D is being designed around three distinct parts of the game-creation workflow.
Studio is the creation environment.
It is where developers will manage projects, build scenes, define game behavior and work with assets. Studio coordinates the workflow, but it is not intended to become the game runtime itself.
Preview is the testing environment.
It takes a project through the real compilation and runtime pipeline, allowing the game to run inside the browser while remaining connected to Studio. This separation helps testing reflect how the project actually behaves instead of relying on an editor-only simulation.
Release builds are the final exported games.
The long-term goal is for exported projects to run independently, without requiring Studio or a permanent connection to EBAL2D services. Developers should retain control over where and how their games are distributed.
Together, these parts form one connected path:
Create in Studio → test in Preview → export an independent release
The internal Studio and Preview foundations are already being built and verified. The complete public workflow and release export system are still in development.
Keeping these environments separate from the beginning gives EBAL2D a clearer foundation for testing, sharing and distributing real 2D games.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #011 — Builds Tailored to Each Project
EBAL2D has completed and accepted its project-specific optimization foundation.
The engine can now determine which capabilities a project actually uses and produce a specialized build around that exact set.
Depending on the selected build profile, EBAL2D can preserve development and measurement tools or prepare a more focused release-oriented output.
The completed system includes:
• deterministic analysis of used project capabilities;
• removal of unreachable compiler and runtime functionality;
• specialized WebAssembly module selection;
• exclusion of unused assets from build membership;
• separate development, Preview, measurement and release profiles;
• exact reporting of what was preserved or removed;
• safe fallback behavior when usage cannot be proven reliably.
Optimization remains separate from instrumentation. A measurement build can retain the debugger and profiler while still removing unrelated functionality.
Current status
✅ Project-specific optimization complete
✅ Compiler, WebAssembly and asset specialization verified
✅ Deterministic build identities and cache separation accepted
✅ Development and measurement tooling can be preserved when required
⚪️ This does not guarantee that every project will automatically become faster
⚪️ Public release exporting is not available yet
This milestone gives EBAL2D a verified path toward smaller and more focused builds without sacrificing correctness, reproducibility or diagnostic visibility.
The engine can now shape its output around the game being built instead of treating every project as if it requires everything.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and accepted its project-specific optimization foundation.
The engine can now determine which capabilities a project actually uses and produce a specialized build around that exact set.
Depending on the selected build profile, EBAL2D can preserve development and measurement tools or prepare a more focused release-oriented output.
The completed system includes:
• deterministic analysis of used project capabilities;
• removal of unreachable compiler and runtime functionality;
• specialized WebAssembly module selection;
• exclusion of unused assets from build membership;
• separate development, Preview, measurement and release profiles;
• exact reporting of what was preserved or removed;
• safe fallback behavior when usage cannot be proven reliably.
Optimization remains separate from instrumentation. A measurement build can retain the debugger and profiler while still removing unrelated functionality.
Current status
✅ Project-specific optimization complete
✅ Compiler, WebAssembly and asset specialization verified
✅ Deterministic build identities and cache separation accepted
✅ Development and measurement tooling can be preserved when required
⚪️ This does not guarantee that every project will automatically become faster
⚪️ Public release exporting is not available yet
This milestone gives EBAL2D a verified path toward smaller and more focused builds without sacrificing correctness, reproducibility or diagnostic visibility.
The engine can now shape its output around the game being built instead of treating every project as if it requires everything.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #012 — The Security Sandbox Foundation Is Complete
EBAL2D has completed the local implementation and acceptance of its first security sandbox foundation.
As the engine becomes more extensible, project logic and future tooling must operate through clearly defined boundaries. Code should receive only the capabilities it has been explicitly granted, and denied operations must fail safely instead of silently bypassing the rules.
This stage establishes the internal foundation required to isolate execution, validate access and keep engine-owned resources under controlled authority.
The completed work focuses on:
• explicit trust and capability boundaries;
• deny-by-default access decisions;
• controlled interaction with engine resources;
• bounded execution and failure handling;
• deterministic policy results and diagnostics;
• protection against stale or invalid operations;
• verification of both permitted and rejected paths.
Current status
✅ All Security Sandbox work packages complete
✅ Local implementation and acceptance complete
✅ Formatting, linting and project verification pass locally
✅ Fail-closed security behavior covered by tests
⚪️ Public Studio and Preview are not available yet
⚪️ This is an internal security foundation, not a claim that every future threat has already been solved
⚪️ Remote or hosted validation is not being claimed in this update
Security is not being added as a final layer after the engine is built. It is becoming part of the architecture before EBAL2D opens its extensibility and authoring workflow to users.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed the local implementation and acceptance of its first security sandbox foundation.
As the engine becomes more extensible, project logic and future tooling must operate through clearly defined boundaries. Code should receive only the capabilities it has been explicitly granted, and denied operations must fail safely instead of silently bypassing the rules.
This stage establishes the internal foundation required to isolate execution, validate access and keep engine-owned resources under controlled authority.
The completed work focuses on:
• explicit trust and capability boundaries;
• deny-by-default access decisions;
• controlled interaction with engine resources;
• bounded execution and failure handling;
• deterministic policy results and diagnostics;
• protection against stale or invalid operations;
• verification of both permitted and rejected paths.
Current status
✅ All Security Sandbox work packages complete
✅ Local implementation and acceptance complete
✅ Formatting, linting and project verification pass locally
✅ Fail-closed security behavior covered by tests
⚪️ Public Studio and Preview are not available yet
⚪️ This is an internal security foundation, not a claim that every future threat has already been solved
⚪️ Remote or hosted validation is not being claimed in this update
Security is not being added as a final layer after the engine is built. It is becoming part of the architecture before EBAL2D opens its extensibility and authoring workflow to users.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #013 — The Studio Workspace Foundation Is Complete
EBAL2D has completed the local implementation and acceptance of its new Studio workspace foundation.
The central rule is simple:
one authoritative Studio session — many synchronized window views.
Panels can now be docked inside the main workspace or detached into separate windows without creating independent copies of the project state.
This foundation includes:
• docking and detachable workspace panels;
• shared project selection and editing context;
• consistent focus and command routing;
• Preview integration without giving Preview authority over the project;
• workspace hosting for debugger and profiler tools;
• layout data stored separately from project content;
• safe recovery to the default workspace when a saved layout is invalid;
• a DOM-independent editor core that is not tied to one browser window.
This architecture is especially important for professional workflows. A developer will eventually be able to keep the scene, project structure, Preview and diagnostic tools across different panels or monitors while continuing to work with one consistent project session.
Current status
✅ All Studio Workspace work packages complete
✅ Docking, detachment and shared-session behavior implemented
✅ Local verification and final audit complete
✅ No blocking or required corrective findings
⚪️ Public Studio is not available yet
⚪️ Production multi-window certification remains ahead
⚪️ The completed result is an internal foundation, not a finished editor interface
EBAL2D Studio is moving from a basic browser shell toward a real creation workspace designed to grow with both simple and professional projects.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed the local implementation and acceptance of its new Studio workspace foundation.
The central rule is simple:
one authoritative Studio session — many synchronized window views.
Panels can now be docked inside the main workspace or detached into separate windows without creating independent copies of the project state.
This foundation includes:
• docking and detachable workspace panels;
• shared project selection and editing context;
• consistent focus and command routing;
• Preview integration without giving Preview authority over the project;
• workspace hosting for debugger and profiler tools;
• layout data stored separately from project content;
• safe recovery to the default workspace when a saved layout is invalid;
• a DOM-independent editor core that is not tied to one browser window.
This architecture is especially important for professional workflows. A developer will eventually be able to keep the scene, project structure, Preview and diagnostic tools across different panels or monitors while continuing to work with one consistent project session.
Current status
✅ All Studio Workspace work packages complete
✅ Docking, detachment and shared-session behavior implemented
✅ Local verification and final audit complete
✅ No blocking or required corrective findings
⚪️ Public Studio is not available yet
⚪️ Production multi-window certification remains ahead
⚪️ The completed result is an internal foundation, not a finished editor interface
EBAL2D Studio is moving from a basic browser shell toward a real creation workspace designed to grow with both simple and professional projects.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.
Development Update #014 — Scene and Object Editing Comes Together
EBAL2D has completed and locally accepted the Scene and Object Inspector foundation for Studio.
The Inspector provides a shared, structured way to view and edit object properties. Its fields are generated from schemas rather than being hard-coded for individual object types.
The completed foundation supports:
• text, number, boolean and enum properties;
• positions, angles and colors;
• asset references, including sprite assets;
• read-only values;
• editing multiple selected objects;
• clear handling of properties with mixed values;
• shared Undo and Redo across docked and detached windows;
• keyboard command routing through the authoritative Studio session;
• validated Scene JSON persistence and migration;
• safe delivery of updated scene state into Preview.
Studio workspace layouts and project scenes remain separate. Changing a panel arrangement cannot modify project content, while a damaged layout can safely return to its defaults without affecting the scene.
Preview also remains a projection of the authoritative Studio state. Outdated updates are rejected instead of replacing newer project data.
Current status
✅ All 14 Scene/Object Inspector work packages complete
✅ Inspector and multi-selection editing implemented
✅ Shared cross-window Undo and Redo verified
✅ Scene save, reopen and Preview projection verified
✅ Local host tests: 161/161 passed
✅ Targeted, full and clean Docker verification passed
⚪️ Public Studio is not available yet
⚪️ Production browser and multi-monitor certification remain ahead
This milestone connects the Studio workspace to real scene authoring foundations. EBAL2D is moving closer to an editor where creators can work with game objects through clear, predictable tools.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D has completed and locally accepted the Scene and Object Inspector foundation for Studio.
The Inspector provides a shared, structured way to view and edit object properties. Its fields are generated from schemas rather than being hard-coded for individual object types.
The completed foundation supports:
• text, number, boolean and enum properties;
• positions, angles and colors;
• asset references, including sprite assets;
• read-only values;
• editing multiple selected objects;
• clear handling of properties with mixed values;
• shared Undo and Redo across docked and detached windows;
• keyboard command routing through the authoritative Studio session;
• validated Scene JSON persistence and migration;
• safe delivery of updated scene state into Preview.
Studio workspace layouts and project scenes remain separate. Changing a panel arrangement cannot modify project content, while a damaged layout can safely return to its defaults without affecting the scene.
Preview also remains a projection of the authoritative Studio state. Outdated updates are rejected instead of replacing newer project data.
Current status
✅ All 14 Scene/Object Inspector work packages complete
✅ Inspector and multi-selection editing implemented
✅ Shared cross-window Undo and Redo verified
✅ Scene save, reopen and Preview projection verified
✅ Local host tests: 161/161 passed
✅ Targeted, full and clean Docker verification passed
⚪️ Public Studio is not available yet
⚪️ Production browser and multi-monitor certification remain ahead
This milestone connects the Studio workspace to real scene authoring foundations. EBAL2D is moving closer to an editor where creators can work with game objects through clear, predictable tools.
🌐 https://ebal2d.com
#EBAL2D #Devlog
EBAL2D
EBAL2D — Browser-Native 2D Game Engine
EBAL2D is a browser-native 2D game engine and creation platform for building, editing and testing interactive 2D worlds.