BJORGXR

Every object in bjorgxr is alive. It has its own AI, its own memory, and its own appearance. You can talk to it. Ask it to change. It talks to other objects. It can become anything — a communication app, a database, a video game, an entire virtual world.

Built in Scandinavia.EU sovereign tech.

What is bjorgxr?

A platform where digital things are alive. Every object has its own AI, its own memory, and its own visual representation. They talk to each other. They can become anything.

Everything is an object

We call them “Ting.” A Ting can be anything — an app, a 3D model, a database, a chat window, a video player. It carries its own data, its own behavior, and its own visual representation.

Every object thinks

Every Ting has its own AI. It can reason about itself, talk to other Ting, and decide what to do next. You can have a conversation with any object in the system.

Objects change themselves

Ask a Ting to change and it rewrites its own code. Tell it to look different and it updates its own appearance. The system evolves while it’s running. No compilation necessary.

What can a Ting become?

A Ting is a universal building block. The same object model handles all of these:

Web app
3D world
Database
Chat bot
API service
Game character
Dashboard
Video player
IoT sensor
Document
Neural network node
Anything else
The bjorgxr editor: a preview showing a red cube, a chat where AI updates the object, and the inspector with all props and methods

How it works

Talk to an object. It changes itself. The world updates in real time.

This screenshot depicts a Ting changing its internal behaviors and appearance based on the conversation with the user. This is not a mockup. It is the actual working prototype.

The bjorgxr editor in action

Visual representation

Objects define their own appearance. A red cube, an Excel sheet, a video player, an NPC in a virtual world — it can be represented as anything.

Talk to it

Tell it to become a communication app, a neural network, a virtual world — it reshapes itself into whatever you describe.

XR compatible

The editor works both on your laptop, phone, and in virtual reality.

A visual editor for living objects

Every object opens as a window. You see its data, its behavior, its events. Click to edit. Drag to rearrange. Everything saves automatically.

demo
clone_
data
intcount0
strcolor#8caaee
behavior
tick
.count=add(.count,1)
events
@clock.ticktick

Every object is inspectable

Click on any object and its window opens. You see everything — its data, its behavior, its connections to other objects. Change a value and see the result immediately.

Talk to it

Every object has a chat interface. Ask it to change its color, add a new behavior, or explain what it does. It uses AI to understand your request and modifies itself.

Clone and modify

See an object you like? Clone it. Change one thing. Clone again. No classes, no templates. Just living copies you can customize. Like copying a document and editing the copy.

Objects live in 3D

Every object has a 3D form. It appears in a shared spatial world. Walk around your data. See your objects. Enter VR and stand among them.

The bjorgxr 3D preview showing a cube object in the spatial editor

Screenshot from the actual editor.

Spatial computing

Objects aren't just data in a table. They exist in space. A chat bot is a sphere you walk up to. A database is a grid you can touch. A sensor is a glowing dot on a map.

VR ready

The same objects that render on your screen render in a VR headset. Put on a headset and you're standing inside your system. Reach out and touch an object to inspect it. The editor works in both flat and immersive mode.

Objects define their own look

Each object decides how it appears. A player might be a box. An enemy might be a red sphere. A weather service might be a cloud. Ask the object to change its appearance and it does — because the look is just another property it controls.

One command to run a world

Install the CLI. Create a world. Populate it with objects. Export the entire state as a single file. Send it to someone. They load it and everything is there.

terminal
tom$ bjorgxr new toms-world
created image "toms-world"
tom$ bjorgxr serve toms-world
serving toms-world at http://localhost:3333
tom$ bjorgxr export toms-world snapshot.html
exported toms-world to snapshot.html
# Tom sends snapshot.html to Jerry
jerry$ bjorgxr new jerrys_world
created image "jerrys_world"
jerry$ bjorgxr import jerrys_world snapshot.html
imported player (8 props, 5 types)
imported enemy (6 props, 4 types)
jerry$ bjorgxr serve jerrys_world
serving jerrys_world at http://localhost:3333
# everything is there. same world.

A world in a file

Export captures everything — every object, every piece of data, every behavior, every connection. The result is a single HTML file. Import it anywhere and the entire system comes back exactly as it was.

No setup, no configuration

One binary. No Docker. No database server. No config files. Create a world and start building. Everything runs locally on your machine, or can be scaled across countless servers.

Or skip the world entirely

Have an HTML file? Serve it directly. No need to create a world first.

$ bjorgxr serve game.html

The protocol is HTML

Every tool that understands HTML can talk to bjorgxr. Browsers, AI models, other web services, scripts — they all speak the same language the system already uses.

REST APIOpenAPI 3.1
GET/api/ting
POST/api/ting
GET/api/ting/{id}
PUT/api/ting/{id}/props/{key}
POST/api/ting/{id}/exec/{method}
POST/api/ting/{id}/events/{event}
POST/api/ting/{id}/ask
POST/api/ting/{id}/clone
DELETE/api/ting/{id}

No special client needed

Create a Ting from a script. Read its data from Python. Connect it to a spreadsheet. The API is standard HTTP — anything that can make a web request can control the system.

# create a Ting
curl -X POST localhost:3333/api/ting \
-d '{"id":"sensor"}'
# set a value
curl -X PUT localhost:3333/api/ting/sensor/props/temp \
-d '"22.5"'

AI already understands HTML

AI models already understand HTML. That means every object in the system can be read, understood, and modified by any AI — no special integration, no custom tools. The language the system uses is the language AI already knows.

Every object is its own AI

The AI doesn't sit outside the system controlling it. Each object is an AI. It has its own memory and its own context. Thousands of small AIs, each responsible for one thing, each talking to the others through the same API any external service would use.

One protocol for everything

The file format is HTML. The API format is HTML. The communication protocol is HTML. There's nothing to translate, nothing to convert.

Software that rewrites itself

Ask an object to change and it changes. Not just data — its behavior, its appearance, its connections to other objects. While the system is running.

playerself-rendering
this object controls...
inspect— how it draws its own editor window
data panel— the list of values you see
behavior panel— the list of actions it can take
3D appearance— how it looks in the world
Change any of these and the object immediately looks and acts differently. The editor itself is made of objects — change them and the editor changes.

The editor is made of objects

The toolbar, the file browser, the canvas, the chat window, the color theme — each one is an object. There is no separate “editor application.” The editor emerges from the objects it contains. Change the objects, change the editor.

Talk to it, it changes

Every object has a chat. Tell it “make yourself red” and it updates its own color. Tell it “count faster” and it rewrites its own timer. Tell it “explain yourself” and it describes what it does in plain English.

Clone and evolve

Copy an object, change one thing, copy again. Every object can be the starting point for something new. No templates, no classes. Just living copies that can diverge.

The system grows while running

Objects create other objects. An AI object can spin up helpers and connect them together. No deployment. No restart. The system keeps running while it changes.

✅ Secure
✅ European
✅ Sovereign

Aligned with EU Web 4.0

The European Commission's Web 4.0 and Virtual Worlds strategy calls for open, secure, trustworthy digital spaces under EU law. bjorgxr is built for that future — no US cloud dependency, no foreign data access, no non-European AI required.

An app store for objects

Publish objects others can use. Install objects others have made. Like an app store, but for the building blocks of your world.

pkg.bjorgxr.com
search objects...
@bjorgxr/counterv0.2.1

A simple counter that ticks every second

@bjorgxr/chatbotv1.0.0

AI assistant you can drop into any world

@bjorgxr/playerv0.3.0

Game character with health, movement, 3D body

@bjorgxr/weatherv0.1.0

Pulls live weather data, shows it as a 3D cloud

@bjorgxr/dashboardv0.4.2

Connects to any data source, renders live charts

@bjorgxr/teamsv0.1.0

Video calls, screen sharing, meeting rooms in 3D

@bjorgxr/slackv0.2.0

Channels, threads, notifications — as objects you can walk into

@bjorgxr/discordv0.1.3

Voice rooms, roles, bots — a community server as a living world

@bjorgxr/databasev0.3.1

A generic database project ready for you to modify and tweak to your needs

Objects are the packages

An object already carries everything it needs — its data, its behavior, its appearance. Publishing is just sharing. Installing is just adding it to your world.

One command

$ bjorgxr install @bjorgxr/chatbot
installed chatbot
$ bjorgxr publish player
published @you/player v0.1.0

Fork anything

Like an object but want to change it? Install it, modify it, publish your version.

Version history

Every version of every object is preserved. See what changed, compare versions side by side.

Where this is going

bjorgxr is early. Here's what's coming.

VR / AR

Put on a headset and stand inside your system. Walk up to an object and talk to it. The same objects work on a laptop, on your phone, and in virtual reality.

Mesh networking

Connect bjorgxr instances across the internet, local networks, or radio. Objects on different machines talk to each other as if they are running on the same CPU.

Distributed computing

Spread objects across servers. The system decides which objects should be close together for fast communication. Endlessly scalable.

Voice assistant

Talk directly to any object, and have them answer you both in text and optionally with voice. You can tell them to modify themselves, to talk to another object, to set up a later event where they should do something, and more.

Multi-user by default

Collaborate on a 2D screen like in Figma, or walk inside a shared virtual world and see and talk to and collaborate with as many people as you like. Every person is also an object in the application.

Body tracking

Camera modules capture body movement and give every person a live 3D avatar. Walk into a room and you have a body.

Available today

The editor, runtime, and CLI are working. The system is in active development.

Why we're building this

Europe needs its own digital infrastructure. Not reliant on foreign powers.

Today, European businesses, governments, and citizens depend on American infrastructure for everything — office software, cloud computing, AI, communication. Their data crosses the Atlantic. Their compute runs under foreign law. Their AI models are trained on their data, outside their jurisdiction.

The EU is building an alternative. Euro-Office is replacing Microsoft. Sovereign cloud alliances are replacing AWS and Azure. The European Commission's Web 4.0 and Virtual Worlds strategy is charting a path toward open, secure, trustworthy digital spaces built on European values.

bjorgxr is part of that movement. A platform-as-a-service, a programming language, an editor, a virtual world, and a communication system — all in one. Encrypted. Hosted in the EU. No foreign access to your data. No dependency on non-European LLMs. Security first. Trust first. A stronger, sovereign Europe.

Bjorg

Bjorg comes from Bjørgvin, the old Norse name for Bergen, Norway. The word bjørg means protection, help, rescue in Scandinavian languages.

That is what we are trying to do — protection. For our data, our infrastructure, and Europe's digital autonomy. Safe from foreign interference.

Ting

The smallest unit in bjorg is called a Ting — Norwegian for “thing.” Everything you create, inspect, and interact with is a Ting.

The name is inspired by Self, the language that together with Smalltalk, prototyped OOP in a live system. Self called its objects for morphs, from the Greek morphē — “thing.” We did the same, as a tribute.

What we replace

Foreign dependency
US cloud compute (AWS, Azure, GCP)
bjorgxr
Self-hosted engine on EU servers
Foreign dependency
Microsoft 365 / Google Workspace
bjorgxr
Objects that are their own UI
Foreign dependency
OpenAI / Anthropic API dependency
bjorgxr
Scoped AI per object, EU-hosted models
Foreign dependency
Meta's virtual worlds
bjorgxr
EU Web 4.0 virtual worlds
Foreign dependency
Slack / Teams / foreign comms
bjorgxr
Object-to-object messaging
Foreign dependency
React / Next.js / foreign dev stacks
bjorgxr
Visual block language, no framework

How it works in practice

You create a world. You fill it with Tings. They start running.

1

Create a world

A world is just an HTML file. It contains objects. Run the server and your world is live.

2

Add things

Open the editor in your browser. Create objects by cloning existing ones or writing new ones. Give them props, methods, and a visual form.

3

They talk to each other

Objects send messages to each other. One object reacts to another. Every object is AI-powered and can think for itself. Chain enough of them together and you have an application, a game, a simulation, a business, an intelligent system.

4

Deploy it anywhere

Your world runs on any server. Host it in the EU. Share it with others. Connect it to other worlds. Everything stays under your control.