Summary
- Shipped Myra / Trana (trana.app) solo — an AI lesson-material SaaS for Swedish teachers. One TypeScript monorepo ships web, landing, mobile, and desktop clients from shared packages on a Supabase backend.
- Built and operate CE (ce-net.com) — a peer-to-peer compute mesh and economy: capability-chain security, a PoW credit ledger with payment channels, gVisor sandboxing, and 70+ services on top rebuilding Google-class infrastructure (object storage, realtime DB, container orchestration, pub/sub, CDN, IAM). The paid compute economy runs live across a multi-machine fleet.
- Run large language models distributed across heterogeneous machines: ce-exo serves models by wrapping vLLM / llama.cpp / exo behind one OpenAI-compatible API over the mesh; ce-tabnet runs pipeline-parallel WebGPU inference sharded across browser tabs.
- Built and run Rheo (rheo.se) — a ~2M-line Rust resale marketplace with Stripe Connect, PostNord shipping, and three fail-independent monitoring layers; p95 ~78ms on a 256MB container.
- Shipped Blueberry Browser — AI agents operate a real Chromium session via MCP; handles Gmail, LinkedIn, and WhatsApp Web automation with no per-site integrations.
- Designed a Rust/wgpu voxel game engine with SDF traversal, TAA, and bloom running at 60 FPS on Apple A15 and M1.
Distributed Systems & P2P Networks
Built CE ('Sea') — a peer-to-peer compute mesh and economy where every node is assumed hostile and the honest majority wins. libp2p networking with NAT traversal, signed capability chains as the only trust primitive, a custom PoW ledger with escrow and payment channels, and Docker/gVisor sandboxing for workload execution. The paid compute economy is live: usage is metered, admitted, and settled on-chain across a multi-machine fleet (Hetzner relay, GPU workstation, laptops, in-browser WASM nodes). Public relay at ce-net.com; packaged for Homebrew, AUR, Scoop, and Chocolatey.
On those primitives: 70+ services rebuilding Google-class infrastructure as mesh apps — S3-class object storage, a Firestore-class realtime document DB, GKE-style container orchestration, pub/sub, CDN, serverless functions, IAM with passwordless device pairing, distributed CI, and an ngrok-style tunnel service.
Designed the OpenJaws cell mesh platform and its underlying Cell Mesh Protocol: TypeScript/Rust distributed runtime where self-discovering 'cells' gossip-sync a shared atlas and expose type-safe capabilities with no bespoke service-mesh configuration.
LLM Inference & AI Infrastructure
Serve large language models across machines that were never meant to cooperate. ce-exo distributes models over a heterogeneous fleet by wrapping production engines — vLLM, llama.cpp, exo, Ollama — behind one OpenAI-compatible API, with NAT-traversing mesh transport and capability-gated access: one command deploys an engine to a GPU machine and routes chat traffic to it from anywhere. ce-tabnet takes the same idea to its extreme — a transformer sharded layer-by-layer across browser tabs, pipeline-parallel inference on WebGPU.
LLMs also run inside my production systems: policy analysis over payroll data at a gaming studio (LLM tool-use in Rust), lesson-material generation in Trana, and an AI-policy pre-run scanner for work admitted to the compute mesh. Day to day, the engineering process itself runs on fleets of parallel AI agents with recorded conventions and shared backlogs — 500k+ lines of production Rust and TypeScript shipped solo in the last 12 months.
Full-Stack & Performance-Focused Engineering
Proficient in architecting end-to-end solutions across the full stack. Production systems in Rust (Axum/Dominator) for high-performance backends, SvelteKit and React for complex frontends, PostgreSQL for robust data modeling. Integrated Stripe Connect, Slack API, and Fortnox API. Deployed scalable infrastructure using Docker, GitHub Actions, and Cloudflare Tunnels.
Built low-level systems in Rust with focus on performance and memory efficiency: voxel rendering engine (wgpu, ECS, SDF traversal, TAA, bloom) at 60 FPS on mobile SOCs; p95 78ms API response in production microservices; 1.48M messages/sec zero-copy IPC in the Cell runtime.
Agentic Tooling & Rapid Delivery
Shipped Blueberry Browser: an Electron app that exposes an MCP server so AI agents can delegate real-browser tasks — clicking, form filling, reading dashboards — to a live, logged-in Chromium session. No per-site integrations; if a human can do it in a browser, the agent can too.
Self-directed learning focused on understanding technologies from first principles, paired with a habit of shipping. Built and launched Myra / Trana — a multi-platform AI SaaS — solo from a single monorepo; moved Blueberry from concept to daily-use tool in two weeks; open-sourced the Cell Mesh Protocol as a standalone SDK. Committed to clean architecture, maintainable code, and shipping things that actually work.
Case Study: Rheo
Rheo – Resale Marketplace Platform
Mobile-first resale marketplace — roughly 2M lines of Rust. Axum services, React Native client, PostgreSQL, Redis Streams, Stripe Connect, PostNord shipping, and Cloudflare R2. Multi-currency design with a per-listing 'anchor currency' so prices never drift from what the seller chose. Three independent monitoring layers (in-process Sentinel + Cloudflare Worker + Hetzner systemd timer) that fail independently and alert over email and Telegram.
Technologies Used:
Key Metrics
- p95 server response: 78ms (Rust, 256MB container)
- Three fail-independent monitoring layers; blue-green deploys
Architecture
- Axum API → Redis Streams → async workers (Tokio)
- Stripe Connect onboarding + escrow via webhooks
- Docker Compose stack; production deploy via GitHub Actions + Cloudflare Tunnels
- React Native client with Zustand state management and TanStack Query
Technical Highlights
- Complete buy/sell ecosystem with offer negotiation
- Secure payment flows with seller verification
- Asynchronous job processing with real-time progress updates
- Cross-platform mobile app with native experience
Experience
Systems Engineer – Internal AI Tools
Gaming Studio (Umeå)
March 2025 – Present · Umeå, Västerbotten County, Sweden
- Built and shipped an autonomous 'time-guardian' tool in Rust (Axum/Tokio) that ingests employee time reports from Fortnox, analyzes them against company policy with an LLM, and nudges employees over Slack.
- Reduced payroll reconciliation from ~3 days to ~30 minutes; runs unattended with automatic OAuth token refresh and autonomous Fortnox↔Slack identity mapping.
- Secured an admin dashboard behind Google OAuth; wrote property-based tests for the validation engine that caught 11 edge-case bugs pre-production.
- Deployed from a locally hosted Mac Mini via Cloudflare Tunnels with zero downtime in production.
Key Skills:
- Rust
- Axum
- Tokio
- LLM Tool-Use
- PostgreSQL
- Slack API
- Fortnox API
- Google OAuth
- Property-based Testing
- Cloudflare Tunnels
Independent Software Engineer / Founder
Rydenfalk Systems
February 2025 – Present · Umeå, Västerbotten County, Sweden
- Designed and built Myra / Trana (trana.app) solo — an AI lesson-material SaaS for Swedish teachers. One TypeScript monorepo ships web (TanStack Start + React 19 on Cloudflare Workers), landing (Astro), mobile (Expo), and desktop (Electron) from shared packages, on a Supabase backend with RLS.
- Built and operate CE (ce-net.com) — a peer-to-peer compute mesh and economy: run a node, donate compute, earn credits, spend them on other machines. Ed25519 identity, signed capability chains as the only trust primitive, a PoW credit ledger with escrow and payment channels, and gVisor-sandboxed workloads. The paid compute economy runs live across a multi-machine fleet (Hetzner relay, GPU workstation, laptops, browser nodes).
- Built 70+ services on top of CE rebuilding Google-class infrastructure as mesh apps — object storage (S3-class), a Firestore-class realtime document DB, GKE-style container orchestration, pub/sub, CDN, serverless functions, IAM with device pairing, and distributed CI. Grew from Cell, a zero-copy Rust substrate sustaining 1.48M msg/s (~677ns RTT, single core) with embeddable Raft.
- Run large language models distributed across heterogeneous machines: ce-exo wraps production engines (vLLM, llama.cpp, exo, Ollama) behind one OpenAI-compatible API over the NAT-traversing mesh with capability-gated access; ce-tabnet shards a transformer layer-by-layer across browser tabs — pipeline-parallel WebGPU inference.
- Designed OpenJaws cell-mesh platform: TypeScript/Rust runtime where self-discovering 'cells' gossip-sync a shared atlas and expose 100% type-safe capabilities with zero service-mesh configuration.
- Shipped Blueberry Browser — Electron app exposing an MCP server so AI agents operate a real, logged-in Chromium session like a human. Automates Gmail, WhatsApp Web, and LinkedIn daily with no per-site integrations.
- Built a Rust/wgpu voxel game engine (ECS via hecs, hot-reloaded WGSL, SDF-voxel traversal, TAA, bloom) at 60 FPS on Apple A15/M1.
Key Skills:
- Rust
- TypeScript
- React 19
- TanStack Start
- Expo / React Native
- Electron
- Supabase
- libp2p
- Raft Consensus
- Zero-copy IPC (rkyv)
- Docker/gVisor
- MCP
- wgpu
- Distributed LLM Inference
- vLLM / llama.cpp
- WebGPU
- PoW Ledger & Payment Channels
- Capability Security
- Hetzner / Cloudflare
Full-Stack Contractor
Self Employed
January 2024 – May 2025 · Umeå, Västerbotten County, Sweden
- Delivered three commercial codebases (SvelteKit + Node + PostgreSQL) with CI/CD via GitHub Actions.
- Integrated Stripe Connect for split payments; handled PCI compliance via Stripe webhooks.
- Containerized all services in Docker; dev-prod parity < 2 min cold start on new machines.
- Built custom algorithm for personalized feed generation based on user attributes.
Key Skills:
- SvelteKit
- TypeScript
- Node.js
- PostgreSQL
- Stripe API
- Docker
- CI/CD
- Algorithm Design
- OAuth
Programming Languages
Production
- Rust (Advanced: Systems, Backend, Game Dev)
- TypeScript
- JavaScript (ES6+)
- Python
- SQL
- HTML5
- CSS3/SASS
Familiar
- Java
- C++
- C
- WGSL (Shader Language)
- Assembly (Basic)
Full-Stack Web Development
Frontend
- Svelte/SvelteKit
- React
- React Native
- Rust (Dominator)
- Tailwind CSS
- Redux/Zustand
- Webpack/Vite
Backend
- Node.js (Express.js)
- Rust (Axum)
- API Design (REST, GraphQL)
- WebSockets
- Microservices Architecture
Databases
- PostgreSQL
- Redis
- MongoDB
- MySQL
- Data Modeling
- ORM (Prisma, Sequelize)
Systems & Game Engine Development
Architecture & Design
- Game Engine Architecture
- Data-Driven Design
- Systems Architecture
- ECS Implementation (hecs)
Graphics & Rendering
- Real-time Rendering
- wgpu
- Vulkan
- OpenGL
- Ray Marching
- SDF Rendering
- Voxel Rendering
- Post-Processing (TAA, Bloom)
- Shader Programming (WGSL)
Core Concepts
- Low-level Optimization
- Memory Management
- Concurrency & Parallelism
- Real-time Systems
- Type Safety Implementation
Distributed Systems & Networking
P2P & Networking
- libp2p (Gossip, DHT, NAT traversal)
- PoW Blockchain Design
- Capability Chains (attenuation, revocation)
- Circuit Relay & Hole Punching
- Ed25519 Identity & Signing
- Zero-copy / Shared-memory Transports
Cell Mesh Architecture
- Cell Mesh Protocol
- Type-safe RPC (router/procedure)
- Atlas Synchronisation
- Self-healing Topology
- gVisor Sandboxing
Agentic & AI Tooling
- Model Context Protocol (MCP)
- Electron / Chromium Automation
- Claude API Integration
- Multi-agent Development Workflows
- Browser-based Agent Runtimes
LLM Inference & AI Infrastructure
Distributed Inference
- LLM Serving Across Heterogeneous Fleets
- Pipeline Parallelism (layer sharding)
- WebGPU In-browser Inference
- Quantized Models (GGUF)
- OpenAI-compatible API Design
Engines & Runtimes
- vLLM
- llama.cpp
- exo
- Ollama
- GPU Node Orchestration
AI in Production
- LLM Tool-Use in Production Systems
- AI Policy / Content Scanning
- Generation Pipelines (EdTech SaaS)
- Clinical / On-prem Inference Design
- AI-agent-driven Engineering Process
Marketplaces & Financial Systems
Payments & Marketplace
- Stripe Connect (onboarding, split payouts)
- Escrow & Webhook-driven Settlement
- Multi-currency (anchor-currency design)
- PCI-sensitive Flow Handling
- Offer / Negotiation Systems
Ledgers & Credit Economies
- Credit Ledger Design (integer base units, supply caps)
- Payment Channels & Off-chain Receipts
- Usage Metering & Admission Control
- Escrowed Job Settlement (bid/settle/expire)
- Trust & Reputation Economics (earned/spent)
DevOps, Cloud & API Integration
Cloud & Infrastructure
- AWS (EC2, S3, Lambda, RDS)
- Cloudflare (Workers, Pages, Tunnels, R2, DNS)
- Hetzner Cloud (provisioning API)
- Docker / gVisor
- Multi-machine Fleet Operations
- Cross-platform Release CI (Linux, macOS, Windows)
Tools & Practices
- CI/CD (GitHub Actions)
- Git / Version Control
- Blue-Green Deployments
- Package Distribution (Homebrew, AUR, Scoop)
API Integration
- Slack API
- Fortnox API
- Stripe API
- Stripe Connect
- Firebase Authentication
- OAuth
Core Skills & Practices
Methodologies & Quality
- Test-Driven Development (TDD)
- Property-based Testing
- Unit & Integration Testing
- Algorithm Design
- Problem Solving
Professional
- Independent Project Leadership
- System Research & Optimization
- Error Handling & System Resilience
- Technical Communication
- Code Reviews
Other Projects
Myra / Trana — AI Lesson-Material SaaS
An AI lesson-material SaaS for Swedish upper-secondary teachers, built solo. One TypeScript monorepo (Turborepo + pnpm) ships four clients from shared packages: web (TanStack Start + React 19 on Cloudflare Workers), landing (Astro on Cloudflare Pages), mobile (Expo, App Store + Play Store), and desktop (Electron). Supabase backend with row-level security, and a full test pyramid — Vitest, Playwright, pgTAP, and Deno — wired into per-app CI/CD.
Technologies Used:
CE / ce-net — Compute Mesh & Economy
A peer-to-peer compute mesh and economy: run a node, donate compute, earn credits, spend them on other people's machines. Every node is assumed hostile — Ed25519 identity, signed capability chains as the only trust primitive, a PoW credit ledger with escrow and payment channels, gVisor-sandboxed workloads. 70+ services on top rebuild Google-class infrastructure as mesh apps: object storage, realtime document DB, container orchestration, pub/sub, CDN, serverless functions, IAM, distributed CI. The paid economy is live across a multi-machine fleet; public relay at ce-net.com; installers for Homebrew, AUR, Scoop, and Chocolatey. Grew out of Cell, a zero-copy Rust substrate (1.48M msg/s, ~677ns RTT, embeddable Raft).
Technologies Used:
ce-exo + ce-tabnet — Distributed LLM Inference
Large-model inference across machines that were never meant to cooperate. ce-exo serves LLMs over a heterogeneous fleet by wrapping production engines — vLLM, llama.cpp, exo, Ollama — behind one OpenAI-compatible API, with NAT-traversing mesh transport and capability-gated access: one command deploys an engine to a GPU box and routes chat traffic to it from anywhere. ce-tabnet shards a transformer layer-by-layer across browser tabs — pipeline-parallel WebGPU inference where each tab holds a slice of the model. Also designed a clinical deployment (staff chat on hospital GPUs, PHI never leaves the LAN).
Technologies Used:
OpenJaws — Cell Mesh Platform
A distributed computing platform where every service is a sovereign, self-healing 'cell'. Cells gossip-sync a shared atlas, auto-discover typed capabilities, and self-replicate to new nodes via Cell.toml manifests. Production cells span AI inference, Docker management, Hetzner cloud provisioning, live trading, and mobile dashboards. Zero service-mesh configuration — add a directory, it joins the mesh.
Technologies Used:
Blueberry Browser — AI Agent Web Runtime
An Electron browser that AI agents operate like a human. Exposes a Model Context Protocol (MCP) server so any orchestrator (Claude, n8n, cron jobs) can delegate web UI tasks to a real, logged-in Chromium session. No per-site integrations or API tokens — if a human can do it in a browser, Blueberry can too. Used daily for Gmail, WhatsApp Web, and LinkedIn automation.
Technologies Used:
Voxel Game Engine
Rust/wgpu engine built as a Cargo workspace: a reusable engine library (render graph, ECS via hecs, hot-reloaded WGSL shaders, audio, input) drives a hybrid SDF-voxel ray-traversal renderer with TAA, bloom, and atmospheric scattering at 60 FPS on Apple A15 and M1 — plus a separate N-body orbital ('spacetime') simulator running on the same engine.
Technologies Used:
Spacegame — Players Are the Servers
A browser multiplayer space arena with no game server: every player's browser runs the full authoritative simulation in-tab (Rust → WASM + WebGL2) and peers merge state by quorum — replicated authority instead of client-server. Zero-delay prediction, per-RTT update rates, and population-driven persistence: a lone player's world resets, a crowd's world survives because the crowd is hosting it. The relay is just transport and a warm seed. Deploys are gated on a live browser smoke test of the real production path.
Technologies Used:
Cell Mesh Protocol (cell-mesh-protocol-1)
Reference TypeScript/Rust SDK for the Cell Mesh architecture. Provides typed RPC (router/procedure), gossip-based atlas synchronisation, Ed25519 capability proofs, and an ask/tell signal model. Every mesh call is a self-describing Signal forwarded hop-by-hop; cells learn the topology as a side-effect of handling requests. Published as a standalone package — used as the foundation for OpenJaws.