DEV Community: Mario JGT

Building a Local WebGPU AI Agent Inside a Game Engine

Mario JGT — Fri, 04 Sep 2026 08:00:00 +0000

What if a game-engine AI agent could work without an API key or send the project prompt to a cloud model?

I have been building that option into Feather Engine while keeping its existing OpenAI, Anthropic, and Google providers intact. Users can now choose Local AI (WebGPU) in the same agent panel, download the model deliberately, and let it use the engine's real tools rather than a separate demo chatbot.

The architecture

The local path uses AI SDK 6, browser-ai's Transformers.js provider, and a dedicated Web Worker. The first curated model is Qwen3 0.6B in q4f16 form: small enough to be realistic in a browser, but still a roughly 570 MB download.

Model weights live in a Feather-owned browser cache. Nothing downloads until the user confirms it. The UI exposes hardware compatibility, progress, cancellation, loading, unloading, and cache clearing. Local mode does not require a provider key and never silently falls back to a cloud model.

Making the local model control the whole engine

The hard part was not text generation. Feather's agent has 223 engine tools covering scenes, objects, materials, physics, scripts, UI, animation, assets, and project workflows. Sending every definition and the full cloud prompt to a 0.6B model would overwhelm its useful context.

Instead, every tool belongs to a tested capability group. A lightweight router selects the relevant groups for each request while retaining a small core set. The local model therefore receives a compact prompt and a focused tool surface, but every engine capability remains reachable. Both local and cloud models call the same tool instances and mutation layer.

Safety and lifecycle details

Explicit consent before the first model download
WebGPU and shader-f16 checks before loading
Abortable generation without destroying an already loaded model
Worker termination when unloading or switching models
Cache deletion limited to Feather's own model cache
Persisted provider settings that preserve existing cloud keys and model choices

Verification

The implementation currently passes 512 automated tests, a production build, and a rendered browser smoke test for consent, provider switching, and cloud-setting preservation. A real-GPU inference run in the supported desktop/browser matrix remains an important release gate because headless CI cannot meaningfully prove driver behavior.

What I learned

Small local models benefit more from disciplined context design than from pretending they are cloud-scale models. Tool routing, compact instructions, visible download state, and a strict no-fallback privacy contract make the feature feel like part of the engine instead of an embedded model demo.

I am excited about where browser-native agents can go next: stronger curated models, better capability routing, and more work that stays on the user's machine.

Devlog: building a whole stadium from three.js primitives (no 3D assets)

Mario JGT — Wed, 02 Sep 2026 10:12:01 +0000

Devlog: building a whole stadium from primitives

Another Chaos Football Club devlog — this one on how the world is built. Short version: there are no downloaded 3D models. Everything you see is procedural.

Why primitives

Instead of authoring or buying GLB models, every prop — stands, floodlights, arena hardware, decor — is assembled from three.js primitives (boxes, cylinders, spheres) on a fixed candy colour palette. It keeps the download tiny, loads instantly in the browser, and gives the whole game one consistent, cartoony look.

The payoff

No asset pipeline to manage — props are code- Every arena can be re-themed by swapping the palette and a few parameters- Fast iteration: tweak a number, reload, done### Stack TypeScript, three.js for rendering, 2D Rapier for physics. Wishlist Chaos Football Club on Steam: https://store.steampowered.com/app/4945250/Chaos_Football_Club/ Want to test it? Reach out and I'll send you a free Steam key. 🔑

Loop Valley devlog: you draw it

Mario JGT — Mon, 31 Aug 2026 17:00:00 +0000

You draw it — the core verb of Loop Valley, brush dock and all.
Sketch walls and watch the world grow around them. This is the one store screenshot that keeps the UI visible — everything else hides chrome for the money shots.
Wishlist: https://store.steampowered.com/app/4707890/Loop_Valley/

Loop Valley devlog: pasture life

Mario JGT — Sun, 30 Aug 2026 17:00:00 +0000

Cattle in the meadow — Loop Valley is inhabited, not just built.
Small pastoral beats sell the world as alive. Herds spawn in paddocks as the town grows around your walls.
Wishlist: https://store.steampowered.com/app/4707890/Loop_Valley/

Loop Valley devlog: blue hour in the valley

Mario JGT — Fri, 28 Aug 2026 17:00:00 +0000

Blue hour, windows lit — the cozy money shot from Loop Valley.
Day/night is driven by a phase value. Blue hour is a narrow band just before the sun crosses the horizon — worth the tuning time for shots like this.
Wishlist: https://store.steampowered.com/app/4707890/Loop_Valley/

How Feather Engine’s Pixel Art Trees Stay Procedural and Editable

Mario JGT — Thu, 27 Aug 2026 17:02:00 +0000

Building stylized vegetation usually means jumping between the engine and a sprite editor, managing exported sheets, and accepting that every variation becomes another asset. For Feather Engine, I wanted a tighter loop: choose a visual language, shape the tree, and plant it without leaving the editor.

Nine leaf languages, five growth habits

Pixel Art Trees offers nine procedural leaf styles—broad, star, fine, blossom, jungle, ribbon, needle, pod, and quill—alongside five growth habits: young, spread, candelabra, leaning, and ancient. That gives 45 base combinations before changing the palette, seed, scale, or density.

Painted by code, still real 3D

The plugin generates a deterministic 32×32 leaf atlas from code instead of importing bitmap sprites. The live preview uses the same Feather tree renderer that the project will use, so creators are not approving a disconnected thumbnail. The result stays a compact recipe that can be regenerated reliably.

A short editor loop

Install Pixel Art Trees from Feather’s Asset Store, open it from View → Extensions, select a leaf style and growth habit, then adjust the seed and palette while the tree updates. A creator can plant one tree or place a terrain-snapped grove in a click, then continue fine-tuning with the main Tree Builder.

Built for projects, not screenshots

The generated trees use linked tree assets and a shared nearest-filtered atlas. They support wind, chopping, lower-detail rendering, and export. Because the recipe is deterministic and stored as normal project data, it also behaves naturally in Feather’s live collaboration workflow.

Why a plugin?

Keeping this feature in an enableable plugin lets the core editor stay focused while giving environment artists a purpose-built studio. The vegetation logic began in my RPG Mania project; bringing it into Feather turns that game-specific work into a reusable tool for more creators.
Pixel Art Trees is now available in Feather Engine. Grow the world, and keep every tree editable.
https://feather-engine.com/#pixel-trees

A Real Two-User Feather Engine Collaboration Session

Mario JGT — Thu, 27 Aug 2026 17:00:06 +0000

I recorded a real host-and-editor collaboration session in Feather Engine, the local-first open-source 3D game engine.

Project-wide, not viewport-only

The shared state follows the open project across the engine while both people work.

Viewport and scene hierarchy changes.- Object transforms, components, and Inspector fields.- Blueprint graph changes.- Selections and live editing presence.## Host-owned by design The desktop owner starts the session with their own ngrok authtoken and shares the invite. The host remains authoritative for saving, Play mode, and local filesystem work, so collaboration does not require an always-on Feather cloud backend. ## Watch the real session The new website demo shows the session setup, role roster, and live editing workflow from start to finish: https://feather-engine.com/#collaboration ## Current boundary This remains an experimental desktop feature. Use source-controlled project copies and keep backups while the collaboration protocol and project format continue to evolve.

Loop Valley devlog: storybook house facades

Mario JGT — Thu, 27 Aug 2026 17:00:01 +0000

Storybook houses up close — swayback roofs, jettied storeys, Fachwerk timber framing.
Each house in Loop Valley is procedurally assembled from a kit of parts. Getting facades readable at diorama scale took serious art-direction tuning.
Wishlist: https://store.steampowered.com/app/4707890/Loop_Valley/

Tashpile: A Self-Hosted Linux Server Manager That Doesn't Suck

Mario JGT — Thu, 27 Aug 2026 14:00:06 +0000

If you run a Linux VPS or homelab server, you probably know the drill: SSH in, run commands, forget what ports are open, repeat tomorrow.
I built Tashpile to fix that — a simple, self-hosted server manager you install once and forget about (in a good way).
What is Tashpile?
A lightweight web dashboard for Linux servers. Fall Guys-inspired UI, serious functionality underneath.
Quick install
git clone https://github.com/mariojgt/tashpile
cd tashpile && sudo ./install.sh
That's it — Python deps, systemd service, random password, dashboard on port 8888.
Features
• Docker management — install Docker, start the daemon, launch nginx in a container
• Open port scanner — see every listening port, flagged as accessible from the network or local-only
• Web terminal — tab completion, persistent history, quick buttons for ls, docker, ports, logs
• System overview — host, uptime, memory, disk at a glance
Who is it for?
Homelabbers, indie devs with a VPS, anyone who wants a GUI for basic server ops without installing Portainer + Netdata + a separate terminal app.
Tech stack
Python 3.8+, Flask, vanilla JS. No database. Runs as a systemd service. MIT licensed.
Star it if it's useful — issues and PRs welcome!
https://github.com/mariojgt/tashpile

Schedule a Week of Social Posts from Cursor with Postiz MCP

Mario JGT — Thu, 27 Aug 2026 14:00:00 +0000

As developers, we ship fast but promote slow. Social media feels like a distraction — another tab, another tool, another hour lost.
What if your AI coding assistant could schedule your posts too?
That's exactly what Postiz MCP enables. Connect it to Cursor (or any MCP-compatible client), and you can:
• List your connected social accounts
• Draft platform-specific content
• Schedule a full week of posts in one conversation
• Upload media and publish to LinkedIn, X, Dev.to, Instagram, and more
Here's my setup:

Connect Postiz MCP in Cursor
Ask: "Schedule 5 posts this week about [topic]"
Review drafts, tweak tone, confirm
Done — back to coding The real win isn't automation for its own sake. It's removing friction so you actually show up consistently. Building in public only works if you... actually post in public. Try connecting MCP to your workflow. Your future self (and your audience) will thank you.

Feather Engine: The Model Forge Update

Mario JGT — Wed, 26 Aug 2026 21:00:00 +0000

Feather Engine has a major new update focused on faster visual-first 3D creation.
Model Forge brings in-engine 3D modelling, vertex editing, sculptable box hulls, and a polished studio-style render mode. The update also adds Arbor Forge for stylized trees, installable plugins with a dedicated manager, and improved multi-platform production exports.
Feather Engine combines node-based visual scripting, FeatherScript, Rapier physics, AI-assisted scene editing, live runtime previews, and production export tools in one open-source workspace.
Explore the project: https://github.com/mariojgt/featherEngine

A Meadow, a Coastline, and a Procedural World in CUBELANDS

Mario JGT — Wed, 26 Aug 2026 17:00:01 +0000

A new CUBELANDS alpha screenshot captures the Wanderer standing where a flower-filled meadow meets the coast. The first seal-shrine waits beyond the trees, wildlife crosses the sky, and the route forward is visible without feeling prescribed.

Why this frame matters

It is easy to treat a screenshot as a beauty shot, but this one brings several parts of the current build into a single view.

The meadow and shoreline meet as distinct but connected spaces.- Foliage gives the foreground density without hiding the route.- Wildlife adds movement above and beside the player.- The active shrine objective gives the landscape a purpose.This is a capture from the working early-alpha build, not a target render. ## Built from cubes The central technical idea behind CUBELANDS is that its characters, trees, ruins, and bosses are generated at runtime from procedural cubes, with no imported meshes or animation clips. That constraint shapes both the visual identity and the way I build the world. The goal is to keep the landscape readable from a distance while still rewarding the player for wandering into its smaller details. ## What comes next CUBELANDS is a third-person open-world action-adventure planned for Steam. There is no release date or public store page yet, so for now I’m sharing real progress from the build as it takes shape. Where would you go first in this scene: into the forest, down to the beach, or toward the shrine?