In progress: porting BIONIC to Emerald

I build the stuff I actually want to use myself.

My own programming language, my own hosting, my own Minecraft cloud, and research on a bio-neural AI architecture. All self-built, all self-hosted.

View projects Go to AI Cloud login
BlueNet-Hosting Hardware & hosting KryoCloud Minecraft cloud Kryonox Minecraft network Emerald Programming language BIONIC AI architecture
Everything runs on BlueNet hardware: Minecraft on the left, BIONIC on Emerald on the right
Projects

What's taking shape

No showcase filler — these are the projects I actively build and run.

Hosting In progress

BlueNet-Hosting

My hosting company. Game servers, web space and infrastructure — run on my own hardware with my own panel stack.

  • Game servers
  • Web space
  • Own hardware
  • Own panel
bluenet-hosting.com
Minecraft Cloud In progress

KryoCloud

My own Minecraft cloud. Node system, dynamic server groups and templates — built for networks of any size.

  • Node system
  • Server groups
  • Templates
kryocloud.eu
Minecraft Network In progress

Kryonox

My Minecraft network. Own plugins, own systems, running entirely on KryoCloud.

  • Own plugins
  • Runs on KryoCloud
kryonox.com
AI Cloud Being built

BIONIC in the cloud

Access to BIONIC, hosted on BlueNet. Currently being built.

Go to login
Code style

Pureline

Code without noise.

Pureline is my own code style — and everything here is written in it. Guard clauses instead of nested ifs, small units, clear ownership.

  • Linear Flow
  • Explicit Intent
  • Minimal Noise
  • Small Units
  • Clear Ownership
Read the specification Spec 1.1 · 47 rules
Avoid java 
if (request != null) {
    if (request.valid()) {
        var session = sessions.create(request.user());
        return executor.execute(session, request);
    } else {
        return Result.invalid();
    }
}

return Result.empty();
Preferred java 
if (request == null) {
    return Result.empty();
}

if (!request.valid()) {
    return Result.invalid();
}

var session = sessions.create(request.user());
return executor.execute(session, request);
Skills

What I work with

The stack I build with day to day — from the language all the way down to the infrastructure.

Languages
Emerald
Java
TypeScript
Python
Crystal
Lua
PHP
Frontend
Astro
Angular
Vue
Tailwind
HTML5
Backend
Netty
MariaDB
SQLite
Pulsar
Maven
Spigot
DevOps
Docker
Linux
Nginx
Git
Proxmox
WireGuard
Programming language

Emerald

My own LLVM-based language — compiled to native binaries for every OS that LLVM supports, at speeds from close to C up to C level. And the compiler doesn't minimize RAM via a GC: it eliminates it. As much as possible goes into CPU registers, the rest is sorted into six tiers.

Syntax Java-based
Compiler self-hosting
Backend LLVM
Output Native binaries
Performance near C to C
Memory RAM elimination
emerald-lang.eu →
flow_point.ems emeraldc — flow pass 
public class FlowPoint {
    private Int x;
    private Int y;
    public FlowPoint(Int x, Int y) {
        this.x = x;
        this.y = y;
    }
    public Int sum() {
        return this.x + this.y;
    }
}
 
main() {
    FlowPoint point = FlowPoint(10, 20);→ folded
    Int total = point.sum();→ folded
    String label = "sum: " + total.toString();→ inline
    println(label);
}
0 heap allocations 0 gc pauses llvm backend
1
Folded CPU / register / SSA instead of object
2
Inline Data right where it's needed
3
Local Small objects local & near-stack
4
Shard / Pool RAM, but controlled and cheap
5
Root Heap — owned and deterministic
6
Bond Shared heap with ARC-like overhead
Register Shared Heap
AI Research

BIONIC

Bio-Inspired Organic Network for Intelligent Computing

In development crystal → emerald

My own bio-neural AI architecture — and currently the only one that runs on CPU and RAM alone, with solid performance. No GPU cluster, no token sampling, no brute force.

BIONIC doesn't work with tokens and probabilities, but with states. Per request only the neurons needed for the best possible answer activate — the rest of the net stays silent. That way the network understands concepts instead of just guessing the next most likely continuation.

The first test AIs already ran through successfully. Right now BIONIC is written in Crystal — the port to Emerald is the next step, so architecture and language come from one hand.

Selective activation: only the paths to the answer fire
A single unit properties per processing unit
ActivationActivation thresholdStabilityFatigueRelevanceConfidenceTemporal weightingSemantic bindingLocal learning params
Mechanisms how BIONIC thinks

Sparse Activation

Only relevant entry points fire, the rest of the net stays fully inactive. Compute scales with the active structure — not with the total size of the knowledge.

Event-Driven

Processing runs event-driven over prioritized signals, hard-capped by activation budget, spread depth and time limit. Every thinking cycle stays deterministically bounded.

Persistent State

No empty context per request. Topics, memories, relationships and internal modulators stay part of the active network structure across interactions.

Organic Memory

Memory as connected semantic structures with entities, causality and weighting — associative recall by meaning instead of plain text similarity.

Excitation & Inhibition

Excitatory and inhibitory signals compete. Decisions emerge from controlled competition, not just from the strongest activation.

Adaptive Learning

Local plasticity instead of global retraining: strengthen paths, cut unreliable connections, consolidate recurring patterns — at runtime.

Dynamic Clustering

Related units group dynamically into clusters that activate, merge, split or fade in relevance when unused.

Internal Modulation

Modulators like attention, uncertainty, urgency or confidence steer which structures fire and how long a thinking cycle runs.

Processing cycle one thinking cycle, step by step
  1. 1 Input signals are translated into internal stimuli.
  2. 2 Relevant entry units and clusters are activated.
  3. 3 Activity spreads across weighted connections.
  4. 4 Inhibitory and modulating signals constrain and prioritize.
  5. 5 Relevant memories and states enter working memory.
  6. 6 Multiple interpretations and responses compete.
  7. 7 A stable internal state or decision emerges.
  8. 8 The result is handed to the action, language or control layer.
  9. 9 Successful or faulty paths are adjusted locally.
  10. 10 The updated state persists into the next cycle.
In comparison Transformer vs. BIONIC
Classic transformers BIONIC
Dense matrix computation Selective activation
Linear token context Persistent state network
Full forward pass Event-driven processing
Static parameter structure Adaptive network structure
Context as a sequence Context as an active state
Memory as text or vectors Memory as semantic structures
Activation without explicit inhibition Active competition and inhibition
GPU-centric processing CPU- and RAM-first
Global training Local and structural adaptation
Response generation as main function Cognition and expression separated
AI Cloud

BIONIC, ready to use

The AI Cloud is the way into BIONIC — hosted on my own infrastructure at BlueNet-Hosting. It is currently being built.

  • Runs on CPU & RAM

    No GPU farm behind it. BIONIC only needs regular server hardware.

  • State persists

    No empty context per request. Topics and memories stay active across interactions.

  • Self-hosted

    Runs on BlueNet hardware, not at a big cloud provider.

Go to login
BIONIC Being built
Sparse activation: per request only the units that are needed fire
Ecosystem

Everything interlocks

The projects aren't a loose portfolio — each one builds on the others.

  1. 1

    BlueNet-Hosting provides the hardware

    Own servers, own network, own panel — the base everything else runs on.

  2. 2

    KryoCloud orchestrates the servers

    The node system distributes and scales Minecraft servers across the BlueNet infrastructure.

  3. 3

    Kryonox runs on KryoCloud

    The network is the real-world test of the cloud — with its own plugins and systems.

  4. 4

    Emerald becomes the foundation

    BIONIC is ported from Crystal to Emerald — own architecture on own language.