DEV Community: FBNonaMe

AnimaStage Lite v1.2.3 — Android studio, video export fixes & official MMD landing pages

FBNonaMe — Sat, 06 Jun 2026 09:19:47 +0000

We shipped a big update to AnimaStage Lite — MMD in the browser (WebGL + WASM)

We just pushed a major update to AnimaStage Lite — a browser-native MikuMikuDance (MMD) studio running entirely on WebGL + WASM (Bullet physics).

👉 No install
👉 PMX / VMD прямо в браузере
👉 MP4 export
👉 Android APK (portrait-first)

🔗 Links

🌐 Official site: https://animastage-lite.app
📱 Android APK (v1.2.3, ~20 MB): https://animastage-lite.app/app-debug.apk
⭐ Lite repo: https://github.com/FBNonaMe/animastage-lite
🎬 Pro edition: https://animastagepro.dev (by gtausa197)

🚀 What’s new in v1.2.3

📱 Android app

Portrait-first mobile UI — Scene / Control / Camera / FX tabs
Immersive fullscreen — edge-to-edge editor
Export length control — set seconds before MP4 / Live record
Video save fix — Android Share sheet after export (Files / Gallery / Drive)
Crash fix — camera button no longer triggers heavy MP4 HQ rendering

🌐 Browser (desktop & mobile)

Same engine as APK — fully client-side
Supports PMX / PMD / VMD, timeline, camera, FX
New mobile layout (≤768px):
- bottom tabs
- menu sheet
- timeline peek

🔍 Website & SEO updates

We added dedicated pages for common searches:

Homepage now includes an Official AnimaStage Project block to clarify authorship and link Lite + Pro versions.

⚡ Try it in 10 seconds

Open → https://animastage-lite.app
Click Try Demo (preloaded Miku scene)
Or upload your own PMX folder

On Android:

use the APK
or just open in Chrome (same engine)

🧠 Why this exists

We’re exploring how far real-time 3D animation workflows can go in the browser:

physics (WASM)
animation
rendering
export

All client-side, no servers.

👤 Authors

AnimaStage Lite — FBNonaMe
AnimaStage Pro — gtausa197

If you build something with it — drop a link 👀
Always интересно посмотреть реальные кейсы.

Browser-based MMD Studio (WebGL + WASM) — No Install

FBNonaMe — Tue, 02 Jun 2026 20:02:32 +0000

Hi 👋

I’ve been building AnimaStage Lite — a browser-native 3D animation studio inspired by MikuMikuDance.

The goal is to push real-time animation workflows fully into the browser.

What it does
Load PMX / PMD models
Play VMD animations
Edit morphs and camera
Export MP4 video
Everything runs locally (no backend)
The interesting part

Playback is easy.

Editing is hard.

Keeping things responsive (~60 FPS) while running:

physics (WASM)
IK
morphs
rendering

…at the same time in the browser required some trade-offs.

What we ended up building
frame-time based performance system (not just FPS)
CPU vs GPU estimation (lightweight)
dynamic resolution scaling
FX throttling under load
basic bottleneck detection
Bonus

Also packaged the same editor into an Android app (WebView-based).

Demo

https://animastage-lite.app

Would love feedback from:

WebGL / WebGPU devs
real-time graphics engineers
people building creative tools

How far do you think browser-based tools can realistically go?

Can MikuMikuDance run fully in the browser? AnimaStage (WebGL + WASM) #discuss

FBNonaMe — Sun, 31 May 2026 12:40:16 +0000

What if you could run MikuMikuDance directly in your browser —
no setup, no plugins, no desktop tools?

That’s what we’ve been building with AnimaStage — a browser-based MMD studio powered by WebGL and WASM.

💡 The idea

MMD is powerful, but setting it up is painful:

Windows-only workflows
plugin chains
manual asset handling
heavy desktop requirements

We wanted to remove all of that friction.

👉 Open a link → load a model → play animation → export video

⚙️ Core (Pro version)

Under the hood, AnimaStage is more than just a viewer.

It includes:

PMX / PMD model support
VMD animation playback
Bullet-style physics (Ammo.js WASM)
Multi-character scenes
Cinematic camera system (paths, easing, tracking)
Lighting system (scene + map + volumetrics)
Full post-processing stack (SSAO, DOF, bloom, etc.)
Offline video export (MP4 via WebCodecs)

At this point, it’s closer to a lightweight stage + cinematic tool than a simple web demo.

🚀 Lite version (recent update)

We also shipped a Lite version focused on accessibility and instant onboarding:

Demo Gallery — load full scenes in ~2 seconds (no files needed)
Pose Library — apply poses without breaking VMD playback
Model Analyzer — auto-check textures, polycount, physics
Curve Editor — edit animation with Bezier curves
Redesigned landing: “Run MMD in Your Browser — No Install”
⚡ Performance improvements

We fixed several core issues:

Removed infinite render/update loops
Fixed console spam (fetch / depth issues)
Stabilized analyzer + PMX metadata updates
Improved runtime consistency
🎯 Goal

Make MMD workflows accessible anywhere — even on weaker devices — directly in the browser.

No install. No setup. Just open and create.

🔗 Try it

https://animastage-lite.app

💬 Discussion

Curious what others think:

How far can browser-based tools actually go?
Where do you see the real bottleneck — CPU (WASM) or GPU?
Would you trust a browser-based tool for real production work?
What would make you switch from desktop → browser?

Would love feedback from:
WebGL / Three.js devs, animation creators, and anyone experimenting with real-time tools.

We built MikuMikuDance that runs entirely in the browser (WebGL + WASM). No install, just open and animate. Would love feedback 👇

FBNonaMe — Sun, 31 May 2026 00:13:50 +0000

FBNonaMe

May 31

We built MikuMikuDance in the browser (WebGL + WASM, no install)

#webgl #javascript #gamedev #opensource

2 min read

We built MikuMikuDance in the browser (WebGL + WASM, no install)

FBNonaMe — Sun, 31 May 2026 00:11:49 +0000

What if you could run MikuMikuDance directly in your browser — no setup, no plugins, no desktop tools?
That’s what we’ve been building with AnimaStage — a browser-based MMD studio powered by WebGL and WASM.

**
💡 The idea

MMD is powerful, but setting it up is painful:

Windows-only workflows
plugin chains
manual asset handling
heavy desktop requirements

We wanted to remove all of that friction.

👉 Open a link → load a model → play animation → export video.

⚙️ Core (Pro version)

Under the hood, AnimaStage is more than just a viewer.

It includes:

PMX / PMD model support
VMD animation playback
Bullet physics (via Ammo.js WASM)
Multi-character scenes
Cinematic camera system (paths, easing, tracking)
Lighting system (scene + map + volumetrics)
Full post-processing stack (SSAO, DOF, bloom, etc.)
Offline video export (MP4 via WebCodecs)

It’s closer to a lightweight stage + cinematic tool than a simple web demo.

🚀 Lite version (new)

We recently shipped a Lite version focused on accessibility and instant onboarding:

Demo Gallery — load full scenes in ~2 seconds (no files needed)
Pose Library — apply poses without breaking VMD playback
Model Analyzer — auto-check textures, polycount, physics
Curve Editor — edit animation using Bezier curves
Redesigned landing: “Run MMD in Your Browser — No Install”
⚡ Performance improvements

We also fixed several core issues:

Removed infinite render/update loops
Fixed console spam (fetch / depth issues)
Stabilized analyzer + PMX metadata updates
Improved overall runtime consistency
🎯 Goal

The goal is simple:

Make MMD workflows accessible anywhere — even on weaker devices — directly in the browser.

No install. No setup. Just open and create.

🔗 Try it

https://animastage-lite.app

💬 Feedback

Would love feedback from:

WebGL / Three.js devs
animation creators
anyone experimenting with browser-based tools

What would you expect from a tool like this?**

Building a Browser MMD Studio with Three.js

FBNonaMe — Fri, 29 May 2026 00:28:11 +0000

MikuMikuDance still lives mostly on the desktop: PMX models, VMD motion, skirt physics, camera work. We built AnimaStage Lite — an open-source browser studio so you can load assets, preview motion, add FX, and export vertical Shorts without installing MMD.

🔗 Repository: https://github.com/FBNonaMe/animastage-lite

🌐 Live demo: https://animastage-lite.app/

🎬 Open the studio: https://animastage-lite.app/app

Why the browser?

Short-form creators need:

9:16 framing and 1080×1920 export
Fast PMX + VMD iteration
Stable WebGL on everyday laptops

AnimaStage Lite is not a full MMD clone — it’s a focused stage: load, animate, light, record.

Stack

Layer	Tech
UI	React 19 + TypeScript
3D	Three.js + React Three Fiber
Build	Vite 6
Physics	Bullet (Ammo.js)
HQ video	WebCodecs + mp4-muxer
Live video	MediaRecorder

All core features run client-side.

What it does

Drag & drop PMX/PMD, VMD, textures, HDR
Timeline + dopesheet + Bézier curves + VMD export
Bullet physics — skirt, hair, accessories
RTX Lite — bloom, DOF, weather, style presets
MP4 HQ (frame-by-frame) and Live recording
Clean capture — no gizmos in the final video
9:16 Lite — lighter render path to reduce WebGL context loss

Optional: MediaPipe mocap, Gemini AI keys, Local/WebRTC collab.

Try it

Online: https://animastage-lite.app/app — drop your PMX + VMD.

Locally:


bash
git clone https://github.com/FBNonaMe/animastage-lite.git
cd animastage-lite
npm install
npm run dev


https://animastage-lite.app/ — landing
http://localhost:3000/app — studio (local)
Optional AI: copy .env.example → .env and set VITE_GEMINI_API_KEY.

Open source
Star ⭐ the repo, open issues, send PRs: https://github.com/FBNonaMe/animastage-lite

MMD models are not bundled — use only content you have rights to publish.

What would you use this for — Shorts, VTuber previews, or learning Three.js? Comments welcome.


---

Sharing lessons and trade-offs from building a Windows admin tool in .NET 8. Would love feedback from people experienced with WPF, async code, or Windows internals.

FBNonaMe — Mon, 02 Feb 2026 00:36:38 +0000

FBNonaMe

Feb 1

What building a Windows admin tool taught me about WPF, async code, and system-level software

#wpf #dotnet #xamarin #architecture

2 min read

What building a Windows admin tool taught me about WPF, async code, and system-level software

FBNonaMe — Sun, 01 Feb 2026 23:48:55 +0000

Over the last months, I’ve been working on a Windows desktop project that forced me to touch almost every uncomfortable part of the platform:
WPF threading, WinAPI, WMI, admin privileges, system services, and async-heavy UI code.

Instead of showing features again, I want to share what this project taught me technically — especially things I didn’t expect when I started.

WPF + async: where most of the pain comes from

At the beginning, I assumed that using async/await correctly would be enough.

It wasn’t.

I ran into:

UI freezes caused by accidental context capture

deadlocks between background tasks and Dispatcher calls

background threads trying to update UI collections

The fix wasn’t “add more async”, but:

being explicit about thread boundaries

isolating system calls from UI logic

treating the Dispatcher as a strict boundary, not a convenience

This changed how I structure ViewModels entirely.

Admin privileges change your architecture

When your software:

manages services

inspects network packets

touches protected registry keys

you can’t assume a single execution mode.

I had to design:

privilege-aware features

clear error states instead of silent failures

fallback behavior when admin rights aren’t available

That alone pushed the project from “utility app” into system software territory.

Safety matters more than features

Early on, I focused on “what can I control”.

Later, the question became:

`

**
“What should I not let the user break?”**
`

Examples:

protecting critical system services from termination

mandatory backups before registry edits

confirmations for destructive actions

logging everything that modifies the system

This mindset shift changed the UI and the internal APIs.

A single tool vs many small tools

The original goal was convenience.

But over time, I started questioning:

Is centralization actually safer?

Does a unified UI reduce mistakes — or increase them?

Where does responsibility end: tool or user?

I still don’t have final answers here.

Why I’m sharing this

I’m early in my career, and this project taught me more than any tutorial:

how Windows really behaves under load

how fragile system-level code can be

how important boring, defensive design is

If you’ve built:

admin tools

monitoring software

system utilities

I’d love to hear what lessons you learned the hard way.

If you prefer longer feedback or discussion, you can also message me on Telegram:
👉 https://t.me/CoreNexusAI

I built a unified Windows system monitor in .NET 8 — lessons, mistakes, and open questions

FBNonaMe — Sat, 31 Jan 2026 09:39:27 +0000

Hi everyone 👋

I’m 20 years old, and over the last months I’ve been working almost daily on a Windows desktop application called System Monitor Suite Pro.

This post is not a promotion and not a “check out my cool app” story.
I’m sharing my experience, the design decisions I made, and the questions I still don’t have clear answers to.

What I wanted to build (and what I didn’t)

Important upfront:
This is NOT an antivirus and NOT a one-click optimizer.

The idea was to build a transparent, admin-oriented system monitoring and diagnostics tool — something that lets you see and control what’s happening in Windows, without magic buttons or hidden behavior.

I was frustrated by having:

one tool for monitoring
another for startup entries
another for registry
another for networking

So I tried to see if a single unified tool could make sense.

Core features

The application currently includes:

Real-time monitoring (CPU, RAM, disks, network)
Process manager (tree termination, suspend/resume, protection of critical system processes)
Startup manager (Registry Run/RunOnce, Startup folders, Task Scheduler, Winlogon)
Registry editor + safe registry cleanup (always with backups)
Network scanner + WiFi analyzer
Packet inspector (admin-only)
Windows restrictions / policy unlocker
Backup & restore utilities
Tray integration, logging, SQLite history

Everything is explicit: if something is modified, you know exactly what and where.

Tech stack & architecture

.NET 8
WPF + MVVM
async/await everywhere (avoiding UI freezes was a hard requirement)
WMI + WinAPI where appropriate
SQLite for history and logs
Inno Setup for a clean installer

A lot of time went into:

async architecture
avoiding deadlocks
handling admin-only APIs safely
graceful degradation when permissions or APIs are unavailable

Hard lessons learned

Some things I underestimated at first:

How easy it is to freeze a WPF UI with a single wrong async call
How many Windows APIs silently fail without clear error signals
How sensitive system-level tools are perceived by users (rightfully so)
How much effort goes into making destructive actions safe

I also learned that not building an antivirus or optimizer actually makes trust harder, because people still expect those labels.

Open questions (this is why I’m posting)

I’d really like honest opinions from people with more experience:

Does a single unified Windows admin tool make sense, or is separation better?
Which parts of such a tool feel inherently risky or unnecessary?
Would you personally trust a tool like this on your own system?
What would you absolutely never include in software like this?

I’m not selling anything and I’m not claiming this is “production ready”.
This is very much a learning-driven project.

If someone wants to discuss deeper or test it hands-on, I’m open to direct conversation — but feedback in the comments is more than welcome.

Thanks for reading 🙏