DEV Community: Mario JGT

Verdant: refining terrain, foliage and cinematic cameras in Feather Engine

Mario JGT — Sat, 26 Sep 2026 10:51:33 +0000

I've been refining the terrain and vegetation system in Feather Engine, my TypeScript game editor. Verdant is a 48-second film that shows the current woodland renderer in six editable camera shots.
The final landscape pass adds 36 rocks in nine asymmetric outcrops, low fern banks and painted clearings. Trees vary in scale and form groves; blade grass follows the terrain and responds to wind. Lighter foreground fog preserves the smaller surface details, while height-based mist and shadow-aware volumetric sunlight add depth at Epic quality.
The camera review mattered as much as the asset work. Branches can extend well beyond a trunk's footprint, so the scene checks its camera corridors against the wood geometry as well as the ground and rock bounds. The closing views were moved into clear space. The film was captured offline at 1920 × 1080, 24 fps; it is a development preview, not a real-time performance benchmark.
Watch the film and download the visual template: https://feather-engine.com/verdant/
Import the project package from the ZIP in a current engine build with the Verdant renderer. Play watches the film, R restarts it, and Stop returns to editing. Open Cinematic to change the named camera shots, or select the woodland terrain to adjust foliage and ground surfaces. The cleaner startup screen also gives the template library a search field and clear project choices.
The visual template embeds 13 visual assets and no audio. Landscape scans and models are CC0 with source credits included; scene logic follows MIT. Add your own soundtrack. The finished film uses an original score and ambience generated through Dev MCP's ElevenLabs tools.

Exploring the elevated railway — gameplay preview

Mario JGT — Mon, 21 Sep 2026 17:00:00 +0000

A gameplay look at the elevated railway and the surrounding city. Flying above the streets gives a different view of the tracks, rooftops and buildings. What would make this part of the city more fun to explore?
Watch the gameplay clip:
https://current-mole-sweet.ngrok-free.app/uploads/2026/09/13/e10c00225aee44195c5e42ac9d921f4aa.mp4

Stopping trains and signing autographs: a new trailer for Stick Hero

Mario JGT — Sun, 20 Sep 2026 18:00:35 +0000

I've put together a new 80-second trailer for Stick Hero: The Beginning, my superhero game.

This one focuses on Infinite City. A small stick figure with a cape has a lot to deal with: a swarm pouring into the street, a train that needs stopping, flying cars, tornadoes, and people who still want an autograph.

The trailer moves between those big action moments and the little interactions in the city. The contrast is a big part of the fun: one minute you're dealing with a disaster, the next you're greeting a fan.

Watch the full 80-second trailer

The footage comes from the game itself, with staged camera shots and an original score. The trailer was captured frame by frame at 60 fps, then edited and mixed in FFmpeg.

The Steam page is up if you'd like to take a look or wishlist it:
Wishlist Stick Hero: The Beginning on Steam

I'd love to hear what you think of the trailer, especially whether the mix of action and silliness comes across.

Gravity powers gameplay — gameplay preview

Mario JGT — Sat, 19 Sep 2026 17:00:01 +0000

A gameplay preview focused on gravity powers and movement around the city. The clip starts in the power selection menu before heading back into the streets. Which power would you try next?
Watch the gameplay clip:
https://current-mole-sweet.ngrok-free.app/uploads/2026/09/13/3273edaa1f91bd8703bd9ca7b20366c9.mp4

Fire powers in the city — gameplay preview

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

A short gameplay clip showing fire effects and destruction in the city. Flames, smoke and scattered debris all compete for attention here. How clearly can you follow the action?
Watch the gameplay clip:
https://current-mole-sweet.ngrok-free.app/uploads/2026/09/13/93d6d4523a281db2582fca926d12b41d.mp4

City exploration and destruction — gameplay preview

Mario JGT — Tue, 15 Sep 2026 17:00:01 +0000

A gameplay tour through the city: streets, rooftops, traversal and destruction. The damage counter keeps track of the mess along the way. What would you explore first?
Watch the gameplay clip:
https://current-mole-sweet.ngrok-free.app/uploads/2026/09/13/710435f5ad21b05e83fbded63a4fa3b101.mp4

The Breaker boss fight — gameplay preview

Mario JGT — Sun, 13 Sep 2026 17:00:00 +0000

A look at the boss encounter with The Breaker. The fight takes place among the traffic and buildings, with an on-screen cue for the dive attack. How readable does the fight feel?
Watch the gameplay clip:
https://current-mole-sweet.ngrok-free.app/uploads/2026/09/13/2b5c21e2fa6c3f4e34eaa9df4ce31bb9.mp4

What I learned running a wishlist push as a solo game dev

Mario JGT — Thu, 10 Sep 2026 10:14:01 +0000

What I learned running a wishlist push as a solo dev

A quick, honest devlog on the marketing side of Chaos Football Club rather than the code.

Wishlists are the metric

Before launch, Steam wishlists are the number that matters — they drive visibility and the launch-day spike. So I've been treating them as the primary goal, not downloads or follows.

What actually moved the needle

Short vertical clips (Shorts/Reels) out-performed static screenshots for reach- A personal "here's what I built and why" post beats a polished ad every time- Offering free keys to testers turned lurkers into sharers### What I'd do differently Start posting earlier, and batch a week of content in advance so momentum doesn't depend on me feeling inspired each day. Wishlist Chaos Football Club: https://store.steampowered.com/app/4945250/Chaos_Football_Club/ Building something similar? Happy to compare notes — and I'll send a free key if you want to see it in action. 🔑

Devlog: capturing smooth game footage from a renderer that never hits 30fps

Mario JGT — Mon, 07 Sep 2026 15:10:31 +0000

Hey guys 👋 Quick devlog on the side project.
I'm building an open-world stickman superhero game. Flat white surfaces, black outlines, no textures and no colour anywhere. The whole city is built from modules on a grid rather than baked meshes, which is the load-bearing decision of the project: destroying a wall is removing a module and building one is adding it back, so destruction and construction are the same system.
This week went into the landscapes, so I wanted a 20 second clip flying through a few of the districts.

The bit that was actually interesting

I wanted the footage captured out of the real game rather than reconstructed in an editor. The obvious approach is to drive it with Playwright and take a screenshot every frame, but that falls apart immediately: rendering under automation is far slower than a screenshot loop can keep up with, so wall-clock capture stutters and the timing drifts.
The fix is to stop letting the clock decide. Before the game boots, hijack requestAnimationFrame and queue the callbacks instead of running them:

replace requestAnimationFrame with a function that pushes the callback onto a queue- expose a step(dt) that advances a virtual timestamp and drains the queue- call step(1000 / 30) once per screenshotEvery captured frame now advances the simulation by exactly 1/30th of a second, whatever the renderer is actually doing. A frame that takes 300ms to draw and a frame that takes 8ms produce identical motion. The result is smooth 30fps footage from a renderer that never once hit 30fps, and it is deterministic — the same seed gives you the same clip every time. The same rig drives the camera: for the aerials it detaches the chase camera and dollies an external one between two framings, and for the traversal and combat shots it just feeds synthetic input to the real player controller. Nothing in the video is staged. ## Stack Three.js driven imperatively, Rapier for physics, React for the HUD only, TypeScript in strict mode, packaged with Tauri. Video's attached. Would love to know which district reads best — the citadel and the industrial yard are the two I'm least sure about.

How does a game know you're there?

Mario JGT — Sun, 06 Sep 2026 20:07:16 +0000

hey guys 👋
we just finished a new animation, and this one is about something every engine has and almost nobody explains properly: how a game knows you're there.
the short version. your character has a collider, the world has trigger volumes, and when the two overlap the engine fires an event. that's it. that's the whole trick behind every door that opens by itself, every cutscene that starts when you walk into a room, and every trap you wish you hadn't stepped on.
instead of writing that on a slide, we drew it. a knight walks into a pink box, the box lights up, a gate opens. two minutes, no code.
hope you enjoy it, and tell me what you want explained next 🙌

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. 🔑