Introducing Ocsidian: The Agentic Game Creation Platform

Today ETAPX is introducing Ocsidian, the agentic game creation platform that takes you from idea to playable world — with speed, taste, and full creative control. Built on the BlackFrost Engine, delivered through the Ocsidian Os desktop editor, and powered end to end by agentic AI workflows, Ocsidian is a single, vertically integrated product for the people who actually make interactive worlds: solo creators, small studios, and teams who refuse to trade ownership for velocity.

For most of the last two decades, building a real-time 3D game has meant assembling a toolchain rather than telling a story. An engine here, an asset pipeline there, a scripting layer that fights you, a physics integration that breaks on update day, a build system that nobody fully understands, and an account-and-licensing maze sitting on top of all of it. The act of creation got buried under the act of coordination. Ocsidian is our answer to that — a platform where the editor, the engine, the asset pipeline, the scripting system, live preview, and the cloud account all behave like parts of the same machine, because they are.

This is a launch announcement, but it is also a design statement. So in this piece we want to go deep: what the BlackFrost Engine can actually do, how the Ocsidian Os editor turns a blank canvas into a running game, where agentic AI fits without taking the wheel, who Ocsidian is for, and how it connects to the wider ETAPX ecosystem. If you build games — or you have always wanted to and never found a tool that respected both your time and your craft — this one is for you.

What Ocsidian Is — And What "Agentic Game Creation" Actually Means

Ocsidian is a vertically integrated game creation platform. That phrase carries weight, so let us unpack it. "Vertically integrated" means the layers are designed together rather than glued together: a real-time 3D engine (BlackFrost), a native desktop editor (Ocsidian Os), project scaffolding, a cloud account and identity layer, AI-driven workflows, and a modern web presence at ocsidian.ai are all parts of one product line, sharing conventions, data formats, and a single mental model. You are not learning five tools. You are learning one.

"Agentic" is the part people most often misread, so let us be precise. Ocsidian's AI does not generate your game and hand you a black box. Agentic workflows mean the platform can take a described intent — "set up a third-person controller with a follow camera," "rough in a navmesh for this level," "wire this material's emissive to a pulse" — and carry out the multi-step work to get there, inside the editor, where you can inspect, adjust, and override every result. The agent is a collaborator that handles the connective tissue: the boilerplate, the wiring, the repetitive setup that stands between you and the thing you are actually trying to express.

"We built Ocsidian for the moment in every project where the idea is clear in your head and the tool is the only thing in the way. Agentic workflows exist to remove that friction — never to remove the author."

— ETAPX Product Team

The product's own tagline says it cleanly: from idea to playable world, with speed, taste, and full creative control. Speed is what the engine and the agents deliver. Taste and control are what we refuse to automate away. That balance is the entire thesis of the platform.

The BlackFrost Engine: A Real-Time 3D Engine Built for Modern Hardware

At the core of Ocsidian sits the BlackFrost Engine — the proprietary runtime and editor core that does the heavy lifting. BlackFrost is a full real-time 3D engine, not a renderer bolted onto a UI. It owns scene composition, rendering, physics, scripting, asset management, animation, navigation, and the visual authoring tools that sit on top of all of it. Everything else in Ocsidian is, in some sense, a surface for driving BlackFrost.

What distinguishes BlackFrost is a deliberate philosophy about where real-time graphics are headed. The team's internal governing rule says it bluntly: shader math is cheap; draw calls and unique geometry are expensive. AAA forests run at sixty frames per second not because the trees are simple, but because five hundred trees are a handful of instanced draw calls sharing one excellent foliage shader — not five hundred unique meshes. BlackFrost is engineered around that truth: minimize GPU submissions and the cost-per-pixel of light transport, never the richness of the material math. That is how you get cinematic surfaces and large worlds in the same frame budget.

Scene Graph and Rendering

BlackFrost provides a complete 3D scene composition pipeline. You build worlds as a scene graph of nodes — meshes, lights, cameras, physics bodies, particle systems, GUI elements — each fully inspectable and editable. On top of that graph rides a physically based rendering pipeline that targets the look creators actually want:

• PBR materials: physically based shading using a Cook-Torrance lighting model with energy-conserving multiscatter, so metals, dielectrics, glass, stone, wood, and weathered surfaces respond to light the way real materials do.
• Environment and IBL lighting: image-based lighting from HDR environments, paired with a sun-and-sky model, gives scenes grounded, believable ambient light instead of flat fill.
• Shadows: high-quality shadow rendering, including cascaded shadow maps and image-based-lighting shadow techniques for contact-accurate grounding.
• Post-processing stack: screen-space reflections (SSR), screen-space ambient occlusion (SSAO), temporal anti-aliasing (TAA), motion blur, and volumetric light scattering — the effects that separate a tech demo from something that reads as a finished frame.

The rendering pipeline is configured in the editor through a real pipeline layer — SSR, SSAO, TAA, IBL shadows, volumetric light scattering, and motion blur are each individually tunable passes, not a single locked preset. That matters because art direction lives in the details, and BlackFrost gives you the dials.

Where BlackFrost Is Going: Unreal-Class Rendering on Modern Targets

BlackFrost is not standing still, and the platform's research program is unusually candid about ambition. The goal is long-form, AAA-grade visuals — millions of source polygons on screen via virtualized and instanced geometry, real photographic-density materials, dynamic global illumination, reflections and volumetrics, and film-grade surface shading for foliage, skin, hair, and wet or weathered surfaces — at a default sixty-frames-per-second budget. These are stated targets and active research directions, not finished claims, and the team frames them that way internally. But they reveal the trajectory: BlackFrost is being built to deliver the techniques proven in the AAA field, re-derived for modern GPU-driven pipelines, without lowering quality to get there.

That research spans a coherent set of systems: virtualized geometry with meshlet-based level of detail and GPU-driven culling; hybrid global illumination that traces screen-space first and falls back to world-space when rays miss; temporal reconstruction and denoising so the image stays stable in motion; advanced material and surface work including two-sided foliage shading, porosity-driven wetness and aging, and parallax-based surface relief; and simulation systems for ocean water, volumetric fog, wind, and large-scale GPU particles. The point for creators is simple — BlackFrost is designed to keep raising its visual ceiling underneath your project, not to lock you to today's limits.

Physics: Havok, Native to the Editor and the Build

BlackFrost integrates Havok physics with full rigid-body dynamics, collision, and constraint support. This is not a toy physics layer for prototypes — it is industry-standard simulation, and crucially, it runs natively both inside the editor and in your exported project. The Havok physics binary ships as a WebAssembly module with every project template, so the physics you author is the physics that ships. There is no "it worked in the editor but not in the build" gap, because the same engine code path drives both.

Native, in-editor physics changes how you work. You can drop bodies into a scene, tune mass and constraints in the inspector, and feel the result immediately in live preview rather than guessing and re-exporting. For platformers, vehicle handling, ragdolls, destructible props, or any interaction that has to feel right, that tight loop is the difference between a mechanic you tuned and a mechanic you settled for.

Scripting: TypeScript-First, with Decorators and Hot Reload

Game logic in BlackFrost is written in TypeScript — a deliberate choice. TypeScript gives creators a fast, expressive, strongly typed language with an enormous ecosystem, and it lets the editor and the runtime speak the same dialect. BlackFrost's scripting system is decorator-driven: you annotate class properties with decorators that the editor understands, and those properties surface automatically as editable fields in the inspector. The bridge between code and the visual editor is built in, not bolted on.

Choosing TypeScript over a bespoke scripting language was a decision with real consequences, and we want to be honest about why we made it. A proprietary language locks creators into a dialect they can only use inside one tool, with no transferable skills, no outside libraries, and no community to learn from. TypeScript inverts all of that: it is a language millions of developers already know, backed by the entire JavaScript and npm ecosystem, with first-class tooling for types, refactoring, and debugging. For a small studio, that means you can hire for skills that already exist and reach for packages that already work. For a solo creator, it means the time you invest in learning the language pays off well beyond this one engine.

The other half of the scripting experience is hot reload. Change a script, and the running scene picks it up without a cold restart. Combined with editor-aware metadata for visual property binding, this means you can iterate on behavior the way you iterate on visuals — continuously, in context, with the game running. Here is what that loop looks like in practice:

1. Author: write a component as a TypeScript class, decorating the properties you want to expose to the editor.
2. Bind: those decorated properties appear in the inspector, where you tune them visually against the live scene.
3. Hot reload: save the file and the change propagates into the running preview without losing your place.
4. Refine: adjust values in the inspector, see the effect instantly, and commit the ones that feel right back into code.

This is the workflow that experienced engineers have always wanted from a game editor and rarely gotten: real code, real types, and a visual layer that respects both.

The Asset Pipeline: Drag, Drop, and Done

Assets are where many engines quietly waste your day. BlackFrost's pipeline is built to make import boring in the best way. You drag and drop 3D models, textures, HDR environments, materials, sounds, particle definitions, sprites, and GUI layouts directly into the editor, and the engine handles the rest — including the parts that usually require a manual optimization pass.

• Broad format support: models, textures, audio, environments, materials, particles, sprites, and GUI layouts are all first-class import targets.
• KTX2 transcoding: textures are transcoded to KTX2, a GPU-friendly compressed format that loads fast and stays small — so your worlds are lighter without you hand-tuning every texture.
• Compressed texture caching: the pipeline caches compressed textures so repeated loads and previews stay quick, keeping the iteration loop tight.
• Automatic material application: imported objects get materials wired up on the way in, so a dropped model arrives looking like itself, not like untextured gray clay.

The result is that asset import stops being a project. You bring in what you made or sourced, and you are immediately composing with it.

Animation and Cinematics, with Render-to-Video

BlackFrost ships a timeline-based animation editor with the controls serious animation work requires: curve editing, keyframe manipulation, and animation group management. On top of per-object animation sits a cinematic sequencing layer for staging shots, camera moves, and timed events — and the whole thing can be rendered out to video directly from the engine.

Render-to-video is a quietly important feature. It means your game engine is also your trailer tool, your cutscene tool, and your marketing-clip tool. You author the cinematic against the exact assets and lighting that ship in the game, then export a finished video without rebuilding the scene in a separate package. Announce trailers, social clips, in-game cutscenes, and pitch reels all come from the same source of truth.

Navigation: Navmesh and Recast Pathfinding

For anything with AI agents that move — enemies, companions, crowds, wildlife — BlackFrost includes built-in navmesh generation and editing with Recast integration. You generate a navigation mesh over your level geometry, edit it where you need to, and your AI gets robust, industry-standard pathfinding. This is the kind of system that is painful to assemble from third-party pieces and invaluable when it just exists. In Ocsidian, it just exists, and agentic workflows can help rough in navigation setup so you are tuning behavior rather than plumbing it.

Visual Node Editors: Materials, Particles, Geometry, Render Graphs, and Flow

Not everything should be code, and BlackFrost embraces that with a full family of visual node editors. These give artists and designers direct authorship over systems that would otherwise demand engineering time:

• Node Material Editor (NME): build complex, custom materials by wiring nodes — no shader code required, full shader power available.
• Node Particle Editor (NPE): design particle systems visually, from sparks and smoke to ambient atmosphere.
• Node Geometry Editor (NGE): generate and manipulate geometry procedurally through a node graph.
• Node Render Graph Editor (NRGE): compose the rendering pipeline itself as a graph, giving technical artists control over how frames are assembled.
• Flow graphs: author logic and event flow visually for behavior that does not need to live in TypeScript.

This dual-track approach — real code for engineers, visual graphs for artists and designers — is what lets a small team punch above its weight. Different people work in the representation that fits them, on the same project, against the same scene.

The Inspector: One Pane of Glass for the Whole Scene

Tying the engine together is a full property inspector that understands every object type in the scene: nodes, materials, lights, cameras, physics bodies, particle systems, and GUI elements. Whatever you select, the inspector shows its properties — including the script properties exposed through decorators — and lets you edit them live. It is the connective tissue between visual authoring, scripting, and the running game, and it is the reason the editor feels like one tool instead of a stack of panels.

How BlackFrost Builds a Frame

It helps to understand, at a high level, what the engine is actually doing sixty times a second — because the structure explains why BlackFrost can carry rich materials and large worlds at the same time. The engine organizes rendering as a graph of passes rather than a fixed sequence, which means each stage is an explicit, tunable step rather than a black box. The frame moves through a recognizable arc:

1. Scene preparation: the engine gathers scene state and camera information and organizes instances and clusters spatially, so the GPU is fed efficiently rather than per-object.
2. Culling: the engine determines what is actually visible — frustum and occlusion tests remove what the camera cannot see, so the GPU never pays for hidden geometry.
3. Geometry pass: visible geometry is rendered, writing out the surface data — albedo, normals, roughness, motion — that lighting will consume, with material classes handling glass, stone, wood, foliage, and more.
4. Lighting: ambient occlusion establishes a stable base, then image-based and direct light, global illumination, reflections, and volumetric effects are composited on top.
5. Temporal resolve: the engine reprojects and stabilizes the image across frames with temporal anti-aliasing, so the picture stays clean in motion rather than shimmering.
6. Post-processing: bloom, depth of field, tone mapping, and the final resolve turn the lit image into the frame you see.

The key creative takeaway is that this pipeline is configurable. Because rendering is expressed as a graph — and because technical artists can even author render graphs visually through the Node Render Graph Editor — you are never locked into one look. The same engine that produces a stylized, flat-shaded scene can produce a moody, volumetric, reflection-heavy one. The frame is yours to shape.

Ocsidian Os: The Native Desktop Editor

If BlackFrost is the engine, Ocsidian Os is the cockpit. It is a native, Electron-based desktop editor that ships as a standalone application for both macOS and Windows. Native matters here: the editor runs the engine locally, drives live preview locally, and manages your projects on your machine, with the cloud handling identity and account rather than gating your creative loop behind a network round-trip.

From Launch to a Running Project

The Ocsidian Os experience is designed to get you building fast. It opens to a branded home screen with your recent projects, account sign-in, and one-click new-project creation. When a project loads, a premium splash screen with progress indication and rotating tips covers the load, and then you are in the full 3D editing environment. The path from "I want to make something" to "I am editing a scene" is intentionally short.

Template-Based Project Scaffolding

New projects start from real, pre-configured templates rather than an empty folder. Ocsidian ships five official starters, each wired up with the engine packages, Havok physics, editor tooling, TypeScript with decorators enabled, and Tailwind for styling:

• Next.js: a React-based web project with server-side rendering support, for teams who want their game to live inside a modern web app.
• Electron: a native desktop application target, for shipping standalone games.
• Vanilla TypeScript: a minimal, framework-free project for maximum control and the lightest possible footprint.
• Solid.js: a reactive web project with fine-grained reactivity, for performance-minded web builds.
• Nuxt.js: a Vue-based web project with server-side rendering, for the Vue ecosystem.

Every template arrives with the Ocsidian engine packages, the Havok physics WASM binary, and the editor tooling already in place. You are not assembling a build — you are picking a starting line that already works, then making it yours.

One-Click Live Preview

Live preview is the feature you will use a thousand times a day. One click launches a local dev server and opens your project in a browser for real-time testing. Because the editor, the engine, and the preview all share the same project and the same engine code, what you see in preview is what you built — physics, scripting, materials, and all. The hot-reload scripting loop runs right through this preview, so editing behavior and watching it change live becomes the natural rhythm of the work.

Authentication and the Desktop Bridge

Ocsidian Os uses Supabase-backed authentication with session persistence across windows and app restarts, so you sign in once and stay signed in. Account handoff between the web and the desktop editor flows through a secure deep-link bridge — sign in on the web, and the session hands off cleanly to the desktop app over a protocol-based link, with scoped token storage and automatic refresh handling the security details. It is the kind of plumbing you should never have to think about, which is exactly why we built it to be invisible.

Self-Healing Projects

One of the most quietly valuable parts of Ocsidian Os is its project-repair logic. The editor can automatically patch existing projects with correct import paths, properly linked local engine packages, and the right physics WASM binaries. In plain terms: projects do not rot. When you reopen an older project, or move it between machines, or come back after an engine update, the editor heals the wiring instead of leaving you to debug a broken import map. For anyone who has lost an afternoon to a project that "just stopped opening," this is a genuine relief.

"A creative tool earns trust by never punishing you for stepping away. Self-healing projects, persistent sessions, one-click preview — these are not glamorous features, but together they mean the tool is always ready when you are."

— ETAPX Engineering

Agentic AI Workflows: A Collaborator, Not a Replacement

Ocsidian is, by name and by design, an agentic platform. AI-powered agentic workflows assist throughout the creation process — but the word "assist" is load-bearing. The agents are there to compress the distance between intent and result, handling the multi-step, repetitive, connective work that traditionally eats a creator's time, while leaving authorship firmly in human hands.

Think about where time actually goes in game development. Rarely is it the creative decision itself — it is everything around the decision. Setting up a controller. Wiring a material's parameters to a behavior. Roughing in a navmesh. Scaffolding a new system from a template. Connecting a script's properties to the inspector. These are the tasks an agent is good at: well-scoped, multi-step, and verifiable. Ocsidian's agentic layer takes a described intent and carries out the steps, inside the editor, where every result is inspectable and reversible.

The Principle: Inspect, Adjust, Override

The non-negotiable design rule for Ocsidian's AI is that nothing the agent does is opaque or final. Every agent action lands as real, editable artifacts in your project — a script you can read, a material you can tweak, a navmesh you can adjust, a scene change you can undo. There is no separate "AI output" you cannot touch. This is the difference between a tool that generates games and a tool that helps you make yours. We chose the latter, deliberately, because creators who lose the ability to understand and change their own work have lost the thing that made it theirs.

• Speed without surrender: the agent handles setup and wiring; you keep every creative decision.
• Transparent results: agent output is real code and real assets in your project, not a hidden layer.
• Full reversibility: anything the agent does, you can inspect, change, or undo — it is your scene, always.
• In-context, not off to the side: the agent works inside the editor against your live project, not in a disconnected chat window.

From Idea to Playable World: The Full Loop

Step back and look at how the pieces combine, because the whole is genuinely greater than the sum. Here is the arc Ocsidian is built to support, end to end:

1. Start: open Ocsidian Os, create a new project from a template that already has the engine, physics, and tooling configured.
2. Compose: drag in models, textures, HDR environments, and sounds; the asset pipeline transcodes and wires them automatically.
3. Light and shade: set up PBR materials and IBL lighting, tune the post-processing stack, and author custom materials in the Node Material Editor.
4. Bring it to life: add Havok physics bodies, write behavior in TypeScript with hot reload, and let agentic workflows handle the repetitive setup.
5. Make it move: animate on the timeline, sequence cinematics, and generate navmeshes for AI pathfinding with Recast.
6. Play it: hit one-click live preview and test the real game — physics, scripting, materials, and all — in real time.
7. Iterate: tune in the inspector, hot-reload your scripts, refine until it feels right.
8. Ship and show: export to your chosen target, and render cinematics to video for trailers and clips straight from the engine.

No tool-hopping. No format conversions between stages. No "it worked in the editor" surprises. One platform, one project, one creative flow from the first idea to the playable world.

Who Ocsidian Is For

Ocsidian is built for creators who want professional capability without enterprise overhead — and specifically for three groups who have historically been underserved by the choice between toy tools and intimidating monoliths.

Solo Creators

If you are building alone, your scarcest resource is time, and your most fragile asset is momentum. Ocsidian protects both. The dual-track authoring — code for the parts you want to control precisely, visual node editors for the parts you want to express directly — means one person can cover ground that used to require a team. Agentic workflows absorb the setup and wiring that would otherwise stall you. Self-healing projects and one-click preview keep you in flow. Ocsidian lets a solo creator behave like a small studio.

Small Studios

Small teams live and die by coordination cost. Ocsidian's vertical integration collapses the toolchain so your engineers, artists, and designers all work against the same project in the representation that fits them — TypeScript and the inspector for engineers, node editors and the timeline for artists, flow graphs and live preview for designers. The shared engine and shared conventions mean less time spent on pipeline glue and more time spent on the game. Agentic workflows act like an extra pair of hands for the unglamorous setup work, so your real talent stays pointed at the creative problems.

Teams Who Want Speed Without Losing Ownership

The deepest part of Ocsidian's audience is anyone who has been burned by the trade-off the industry kept offering: move fast with a tool that boxes you in, or keep control with a tool that slows you down. Ocsidian rejects that trade. The engine is full-featured and tunable down to the render graph. The scripting is real, typed code. The agentic AI produces artifacts you own and can change. You get the speed of integration and automation without surrendering an inch of creative control. That is the whole point.

What You Can Build: Concrete Use Cases

Abstract capability lists only get you so far. Here is how Ocsidian's systems combine for the kinds of projects creators actually take on:

• A physics-driven platformer or action game: Havok rigid bodies and constraints give you responsive movement and interaction, the TypeScript scripting loop with hot reload lets you tune feel in real time, and one-click preview means you are playtesting constantly instead of in big risky batches.
• An atmospheric exploration world: HDR environments and IBL lighting ground the scene, the post-processing stack adds volumetric light and reflections, and custom materials authored in the Node Material Editor give surfaces a signature look — all rendered in real time as you compose.
• An AI-populated level: generate a navmesh with Recast, let agentic workflows rough in the navigation and controller setup, then focus your own time on the behavior and encounter design that make the level feel alive.
• A narrative experience with cutscenes: animate characters and cameras on the timeline, sequence cinematics, and render them to video directly from the engine — your gameplay and your story share the same assets and lighting.
• A web-delivered interactive experience: start from the Next.js, Solid.js, or Nuxt.js template and ship a game that lives inside a modern web app, with the engine, physics, and tooling already wired up.
• A procedural or generative piece: use the Node Geometry Editor to build geometry through a graph and the Node Particle Editor for dynamic systems, leaning on visual authoring where code would only slow you down.

The common thread is that none of these require leaving the platform or assembling a separate toolchain. Each is a different combination of the same integrated systems — which is precisely why a small team can attempt any of them.

The Old Way vs. The Ocsidian Way

It is worth being concrete about what changes. The traditional path to a real-time 3D game looks something like this: choose an engine, then separately solve asset import and optimization, physics integration, a scripting bridge, a live-preview setup, a build pipeline, and account or licensing — each a project of its own, each a potential point of failure, each demanding maintenance. The friction is cumulative, and it lands hardest on the smallest teams.

The Ocsidian way folds those concerns into the platform. Asset import and KTX2 optimization are automatic. Havok physics ships with every template and runs identically in editor and build. The TypeScript scripting bridge and inspector binding are built in. Live preview is one click. Project repair heals broken wiring on its own. Authentication and the desktop bridge are handled. And agentic workflows take the multi-step setup off your plate entirely. You spend your hours on the experience you are building, not on the scaffolding around it. That redistribution of effort — from coordination back to creation — is the most important thing Ocsidian does.

Built by ETAPX, Crafted by Iron Hollow

Ocsidian is a product of ETAPX, the technology group behind a growing family of creative and social platforms, in partnership with the Iron Hollow studio. That lineage matters. ETAPX builds tools for creators with a consistent philosophy: amplify human creativity, never replace it; respect the user's ownership and intent; and integrate deeply so people spend less time managing tools and more time making things. Ocsidian carries that philosophy into 3D and game creation. It is dark-first, high-contrast, and intentionally uncluttered — a premium creative environment designed to get out of your way and let the work take center stage.

Being part of the wider ETAPX ecosystem also means Ocsidian is built on a modern, cloud-aware foundation — Supabase-backed identity, a clean web-to-desktop bridge, and a web presence at ocsidian.ai that connects downloads, documentation, and account management into one coherent experience. The platform is engineered to grow with you and with the broader ETAPX family of products.

Frequently Asked Questions

What is Ocsidian?

Ocsidian is an agentic game creation platform from ETAPX. It combines the BlackFrost Engine (a real-time 3D engine), the Ocsidian Os native desktop editor, AI-powered agentic workflows, project scaffolding, and cloud account management into a single vertically integrated product that takes creators from idea to playable world.

What is the BlackFrost Engine?

BlackFrost is Ocsidian's proprietary real-time 3D engine and editor core. It provides scene composition with PBR materials and IBL lighting, shadows, a post-processing stack (SSR, SSAO, TAA, motion blur, volumetric light scattering), integrated Havok physics, TypeScript-first scripting with hot reload, a drag-and-drop asset pipeline with KTX2 transcoding, timeline animation and cinematics with render-to-video, navmesh pathfinding via Recast, and visual node editors for materials, particles, geometry, render graphs, and flow.

Which platforms does Ocsidian Os run on?

Ocsidian Os is a native, Electron-based desktop editor that ships as a standalone application for both macOS and Windows. It runs the engine and live preview locally, with the cloud handling identity and account management.

What does "agentic" mean in Ocsidian — does the AI make my game for me?

No. Agentic workflows take a described intent and carry out the multi-step setup and wiring to achieve it — inside the editor, as real, editable artifacts in your project. The AI handles connective, repetitive work; you keep full creative control. Everything the agent produces can be inspected, adjusted, or undone. It is a collaborator, not a replacement.

What programming language do I use to script games in Ocsidian?

BlackFrost is TypeScript-first. You write game logic as TypeScript classes, using decorators to expose properties to the editor's inspector. The scripting system supports hot reload, so changes appear in the running preview without a cold restart. For non-code authoring, visual node editors and flow graphs are available.

Can I use Ocsidian as a solo creator or small studio?

Yes — that is exactly who it is built for. Ocsidian is designed for solo creators, small studios, and teams who want speed without losing creative ownership. The dual-track authoring (real code plus visual node editors), automated asset pipeline, one-click live preview, and agentic workflows let a small team or an individual cover ground that traditionally required far more people.

What kinds of projects can I create?

Ocsidian ships five official project templates — Next.js, Electron, Vanilla TypeScript, Solid.js, and Nuxt.js — each pre-configured with the engine packages, Havok physics, editor tooling, and TypeScript with decorators. That covers web-delivered games, native desktop games, and lightweight framework-free builds, with the same engine and editor underneath.

How do physics work between the editor and the final build?

BlackFrost integrates Havok physics with full rigid-body, collision, and constraint support, and the Havok WASM binary ships with every project template. Physics runs natively both in the editor and in exported projects via the same code path, so what you author and test is what you ship — there is no editor-versus-build discrepancy.

What Comes Next

Today's launch is the foundation, not the finish line. The BlackFrost research program points clearly at where the engine is heading: virtualized geometry for million-polygon worlds, hybrid global illumination, advanced temporal reconstruction, film-grade material and surface shading, and rich simulation systems for water, weather, and large-scale particles — all targeted at a sixty-frames-per-second budget on modern hardware. These are active directions, and the architecture is being built to deliver them underneath your projects over time, so the work you start in Ocsidian today gets more capable as the platform grows.

On the agentic side, expect the collaborator to get deeper and more useful — more of the setup, wiring, and connective work absorbed, always as transparent, editable artifacts you own. And as part of the broader ETAPX ecosystem, Ocsidian will keep tightening the loop between desktop creation, cloud account, and the web, so the path from idea to playable world stays short no matter where you are working from.

If you make interactive worlds — or you have always wanted to — Ocsidian is built for the way you actually want to work: fast, integrated, and fully yours. Visit ocsidian.ai to explore the platform, read the documentation, and download the editor. We cannot wait to see what you build.