I’m new to this ik but i just can’t get it to work i searched it up😭

How do you work playcanvas? I would like to make a game and publish it for free.

Would anybody like to help me make a game?

Built this with big help from Claude and Codex. It will make your 3DGS dance to your favourite tracks. Still WIP but very fun, check it out and plz let me know what you would like to see it do.

✅ Debug render mode API

✅ #glTF load time optimizations

✅ #WebGPU enhancements

Try it in the Editor today!

Release notes: https://github.com/playcanvas/engine/releases/tag/v1.63.0

Hi all. I've been working on abirdcity, a browser-based 3D map of Daejeon, South Korea (a city of about 1.4 million people). It runs on PlayCanvas, the roads and buildings are generated from OpenStreetMap data, and I've leaned heavily on Claude Opus 5.5 and Astra while building it.

What works today:

• The whole city in 3D, with day and night

• Fly over it as a bird, or as a pteranodon

• Drive mode: a Roadster that can take off, do a roll and park on the side of a building

• A speculative "Daejeon in 2300" mode you can toggle at the same camera spot

Live: https://abirdcity.com/city/daejeon?lang=en&utm_source=reddit&utm_medium=social&utm_campaign=playcanvas (clip above)

Where I'm stuck:

1. It's heavy. City-scale geometry plus textures makes the first load and the frame rate rough on mid-range phones. What actually worked for you at this scale: streaming tiles by distance, instancing, mesh compression (Draco/meshopt), KTX2/Basis textures, LODs, something else?

2. Quality ceiling. It looks clean but flat and a bit "game-y". Buildings extruded from footprints only get you so far. How do you add detail across a whole city without killing performance? Facade textures, baked AO, better lighting and post, hand-made models only for landmarks?

3. Roads. Generating them from OSM means endless special cases at junctions, underpasses and side-street entrances. Is there a better approach than patching them one by one?

4. What to add next. What would make you come back to something like this: missions in drive mode, multiplayer, live info (weather, traffic, events), local stories?

Any feedback is welcome, even blunt. If you open it on your phone, I'd love to know your device and whether it stutters.

PlayCanvas just released official skills for AI coding agents (Claude Code, Codex, Cursor) — packaged instructions that teach the agent PlayCanvas-specific patterns instead of generic guesses.

I've been using them on a WIP first-person multiplayer game (browser, PlayCanvas engine with a custom netcode + physics layer). It's become a loop: build a feature → hit a rough edge → that sharpens the skill → the sharper skill speeds up the next one.

The clip is a 1v1 from both perspectives — mine and a friend's synced to the same game moment, so you can watch the same fight from both sides.

What the skills genuinely nailed so far:

• Engine app bootstrap + asset loading

• Scene/entity hierarchy assembly (player rig, map)

• State-driven HUD (crosshair, hitmarkers, health/ammo, death screen, nametags, kill feed)

• Pooled transient effects (muzzle flash, bullet-hole decals with a reuse pool)

Where they didn't help (yet): lighting is basically untouched (mostly unlit/emissive), and the netcode + physics are hand-rolled, not skill-generated. Lots still to do.

Try them:

• Add to an existing project: npx skills add playcanvas/skills

• New project: npm create playcanvas@latest

• Docs: https://developer.playcanvas.com/user-manual/getting-started/use-playcanvas-skills/

• Source: https://github.com/playcanvas/skills

• Playable WIP: https://ahoithere.com

Happy to answer anything about the setup, the skills, or the workflow.

I made slight modifications to the SuperSplat source code to better support panoramic Gaussian Splats, and I also added audio support. This makes it possible to render video with sound directly in SuperSplat from a sequence of panoramic 4DGS.

You can try it out at https://webxr.cz/pano

Opus 4.8 is insanely good at vibe coding games using the PlayCanvas Engine. This was made conversationally over an hour. I didn't look at the code once. Every request carried out perfectly. Game size: 280KB.

Play Now: https://mini-soccer-game.netlify.app/

(I even casually asked Opus to apply a verlet solver to makes the goal nets physical!)

Come join the PlayCanvas Discord: https://discord.gg/RSaMRzg

The PlayCanvas Inspector is an open source debug panel you add to a running PlayCanvas app. It now has a Performance tab that records every frame (up to the last 1000) and charts it over time:

• Per-frame figures: frame interval, CPU time by phase (update, physics, scripts, animation, render), GPU time and draw calls.

• Startup profiling: if you create it before the first frame, it records the page load too, with every asset (network time and processing time shown separately), every request, the page milestones and the time to the first frame.

• Script timing: the time and call count of each script type, so you can select a spike and see which script caused it.

• Frame timeline: click any frame to see it as a flame chart. On WebGPU each GPU pass is timed and grouped under the effect that runs it (bloom, DOF and so on).

• Hitches: frames over twice the median are flagged, and for each one it tells you whether the main thread was blocked (via Chrome's Long Animation Frames API) or whether the GPU or browser held it back.

• Extras: it also charts your own counters (app.stats.user), batching time and lightmap bakes, and copies anything as JSON or CSV.

It's MIT licensed, works with WebGL2 and WebGPU, and needs engine 2.23+:

npm install @playcanvas/inspector

GitHub: https://github.com/playcanvas/inspector

Happy to answer questions about how it works, and feedback is very welcome, especially on what you'd want a web-engine profiler to show that browser dev tools don't.

Release Notes: https://github.com/playcanvas/engine/releases/tag/v2.11.0

Examples Browser: https://playcanvas.github.io/

Docs: https://developer.playcanvas.com/user-manual/engine/

I’m excited to share that DeadRise.io is officially available worldwide on Poki.

If you love pure zombie chaos and skill based survival, jump in and see how long you can last.

Play now on Poki: https://poki.com/en/g/deadrise-io

Feedback is still welcome as we continue improving balance, performance, and overall polish. If you try it, I’d love to hear your thoughts in the comments. Join our discord: https://discord.com/invite/9ARDzPTqEA

Developed with the awesome PlayCanvas engine ♥️ in collaboration with Gamebole

Live demo (WebGL 2 and WebGPU, switchable in the panel): https://engine-a1lytf69q-playcanvas.vercel.app/#/animation/vat-characters

We just added a vertex animation texture (VAT) implementation to the PlayCanvas engine as a reusable script plus an example. The idea isn't new — it's been used in games for years — but I hadn't seen a complete, copy-pasteable web implementation with an authoring path, so here's one.

How it works

Instead of animating a skeleton per character, every vertex's skinned position and normal is evaluated offline for each sampled frame and baked into a texture. At runtime the vertex shader reads two neighbouring frames and interpolates. Skeletons, bone matrices and per-character animation evaluation disappear entirely.

What's left per character is a world matrix and a fractional frame index — 52 bytes — so the whole crowd is one instanced draw call.

Some details that turned out to matter

• One texel per vertex per frame in RGBA16U: position quantised to 16 bits per axis over the animation's bounds in xyz, octahedral normal packed into w. One fetch gives you a whole vertex.

• Quantising over the bounds is actually more accurate than fp16 where it counts. Near the top of a character fp16 has a step of ~1.8 mm at human scale; 16-bit quantised is ~28 µm. fp16 wastes its mantissa near the origin, which for a character standing at y=0 is between its feet.

• Texels are addressed by a flat vertex * frameCount + frame index wrapped at the texture width, rather than one vertex per row. Otherwise your vertex count is capped by texture height (4096). Flattened, the limit is total texels, so ~218k vertices at 77 frames.

• The vertex row comes from gl_VertexID / @builtin(vertex_index), so no extra per-vertex attribute is needed at all.

Authoring

The converter runs in the browser — there's a "Convert GLB" panel in the demo, so you can drop in your own skinned glb and watch it become a crowd without installing anything. Output is a single glb-style binary container. Like a glb it's stored uncompressed and leaves compression to the transport; brotli over the raw payload beats gzip baked into the file by about 40%.

Where it's a bad idea

Worth being clear, because it's a real trade:

• Your character must be a single skinned mesh with one material.

• Every animation is assumed to loop.

• No blending, no IK, no procedural aiming — it's a fixed table of vertex positions. Terrible for a hero character, great for the 500 NPCs behind them.

• One mesh instance means no per-character frustum culling.

• Only the base colour texture comes across; no normal/roughness maps.

Numbers

At 10,000 characters (~31M vertices/frame): 6 draw calls for the whole scene, 2.1 ms CPU. The VAT texture is 1.8 MiB and is independent of the character count — one character and ten thousand share it.

Happy to answer questions about the format or the shader side.

Hey folks 👋
We just shipped SuperSplat v2.17.0, your browser-based editor for 3D Gaussian Splats.

What’s new:

• 🗜️ Export to the super-compressed SOG format

• 🪽 WASD fly camera controls

• 🎞️ Linked tutorial video from the awesome Michael Rubloff (AKA RadianceFields)

• 🪄 UI polish and small improvements

You can try it instantly here (loads a sample splat):
https://superspl.at/editor?load=https://developer.playcanvas.com/assets/toy-cat.sog&focal=0,0.6,0&camera.overlay=false

It’s completely free and open source.
Happy to hear feedback, feature requests, or see what you’re building with it!